Sign upLogin

JohnMunsch/PaperQuik

View on GitHub
Star
app/bower_components/jquery/dist/jquery.js

Summary

Maintainability
F
1 yr
Test Coverage

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

/*!
 * jQuery JavaScript Library v2.1.1
 * http://jquery.com/
 *
 * Includes Sizzle.js
Severity: Major
Found in app/bower_components/jquery/dist/jquery.js - About 2 wks to fix

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

    (function( window ) {

var i,
    support,
    Expr,
    Severity: Major
    Found in app/bower_components/jquery/dist/jquery.js - About 6 days to fix

      Function ajax has 240 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;
      Severity: Major
      Found in app/bower_components/jquery/dist/jquery.js - About 1 day to fix

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

        setDocument = Sizzle.setDocument = function( node ) {
    var hasCompare,
        doc = node ? node.ownerDocument || node : preferredDoc,
        parent = doc.defaultView;
        Severity: Major
        Found in app/bower_components/jquery/dist/jquery.js - About 1 day to fix

          Function Callbacks has 128 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" ?
          Severity: Major
          Found in app/bower_components/jquery/dist/jquery.js - About 5 hrs to fix

            Consider simplifying this complex logical expression.
            Open

                        if ( event.pageX == null && original.clientX != null ) {
                eventDoc = event.target.ownerDocument || document;
                doc = eventDoc.documentElement;
                body = eventDoc.body;
            Severity: Critical
            Found in app/bower_components/jquery/dist/jquery.js - About 5 hrs to fix

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

              function defaultPrefilter( elem, props, opts ) {
    /* jshint validthis: true */
    var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
        anim = this,
        orig = {},
              Severity: Major
              Found in app/bower_components/jquery/dist/jquery.js - About 3 hrs to fix

                Function trigger has 85 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,
                Severity: Major
                Found in app/bower_components/jquery/dist/jquery.js - About 3 hrs to fix

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

                  function Animation( elem, properties, options ) {
    var result,
        stopped,
        index = 0,
        length = animationPrefilters.length,
                  Severity: Major
                  Found in app/bower_components/jquery/dist/jquery.js - About 3 hrs to fix

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

                    function Sizzle( selector, context, results, seed ) {
    var match, elem, m, nodeType,
        // QSA vars
        i, groups, old, nid, newContext, newSelector;
                    Severity: Major
                    Found in app/bower_components/jquery/dist/jquery.js - About 3 hrs to fix

                      Function add has 68 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,
                      Severity: Major
                      Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                        Function matcherFromGroupMatchers has 68 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,
                        Severity: Major
                        Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

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

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

            // Called once
                          Severity: Major
                          Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                            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 ] ) {
                            Severity: Major
                            Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                              Function superMatcher has 61 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 && [],
                              Severity: Major
                              Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

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

                                    Deferred: function( func ) {
        var tuples = [
                // action, add listener, listener list, final state
                [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
                [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
                                Severity: Major
                                Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                                  Function CHILD has 59 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";
                                  Severity: Major
                                  Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                                    Consider simplifying this complex logical expression.
                                    Open

                                                            if ( forward && useCache ) {
                            // Seek `elem` from a previously-cached index
                            outerCache = parent[ expando ] || (parent[ expando ] = {});
                            cache = outerCache[ type ] || [];
                            nodeIndex = cache[0] === dirruns && cache[1];
                                    Severity: Critical
                                    Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

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

                                          domManip: function( args, callback ) {

        // Flatten any nested arrays
        args = concat.apply( [], args );
                                      Severity: Major
                                      Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

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

                                            init = jQuery.fn.init = function( selector, context ) {
        var match, elem;

        // HANDLE: $(""), $(null), $(undefined), $(false)
        if ( !selector ) {
                                        Severity: Major
                                        Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                                          Function ajaxConvert has 56 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
        dataTypes = s.dataTypes.slice();
                                          Severity: Major
                                          Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

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

                                                data: function( key, value ) {
        var i, name, data,
            elem = this[ 0 ],
            attrs = elem && elem.attributes;
                                            Severity: Major
                                            Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

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

                                                          send: function( headers, complete ) {
                var i,
                    xhr = options.xhr(),
                    id = ++xhrId;
                                              Severity: Major
                                              Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                                                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 ) ) {
                    handlers.splice( j, 1 );
                                                Severity: Critical
                                                Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

                                                  Function remove has 50 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,
                                                  Severity: Minor
                                                  Found in app/bower_components/jquery/dist/jquery.js - About 2 hrs to fix

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

                                                        buildFragment: function( elems, context, scripts, selection ) {
        var elem, tmp, tag, wrap, contains, j,
            fragment = context.createDocumentFragment(),
            nodes = [],
            i = 0,
                                                    Severity: Minor
                                                    Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                      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) );
                                                      Severity: Minor
                                                      Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                        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 + " " ];
                                                        Severity: Minor
                                                        Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                          Function matcherFromTokens has 44 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[" "],
                                                          Severity: Minor
                                                          Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
        var origFn, type;

        // Types can be a map of types/handlers
        if ( typeof types === "object" ) {
                                                            Severity: Minor
                                                            Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                              Function extend has 40 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,
                                                              Severity: Minor
                                                              Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                Function stop has 40 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 );
                                                                Severity: Minor
                                                                Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                      val: function( value ) {
        var hooks, ret, isFunction,
            elem = this[0];

        if ( !arguments.length ) {
                                                                  Severity: Minor
                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                    function addCombinator( matcher, combinator, base ) {
    var dir = combinator.dir,
        checkNonElements = base && dir === "parentNode",
        doneName = done++;
                                                                    Severity: Minor
                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                          each: function( obj, callback, args ) {
        var value,
            i = 0,
            length = obj.length,
            isArray = isArraylike( obj );
                                                                      Severity: Minor
                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                        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;
                                                                        Severity: Minor
                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                              when: function( subordinate /* , ..., subordinateN */ ) {
        var i = 0,
            resolveValues = slice.call( arguments ),
            length = resolveValues.length,
                                                                          Severity: Minor
                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                            function showHide( elements, show ) {
    var display, elem, hidden,
        values = [],
        index = 0,
        length = elements.length;
                                                                            Severity: Minor
                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                  dispatch: function( event ) {

        // Make a writable jQuery.Event from the native event object
        event = jQuery.event.fix( event );
                                                                              Severity: Minor
                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
    var i = 0,
        len = elems.length,
        bulk = key == null;
                                                                                Severity: Minor
                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                  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 = {};
                                                                                  Severity: Minor
                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                    Consider simplifying this complex logical expression.
                                                                                    Open

                                                                                                            } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
                            diff = cache[1];

                        // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
                        } else {
                                                                                    Severity: Critical
                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                      Consider simplifying this complex logical expression.
                                                                                      Open

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

                // Make sure we update the tween properties later on
                                                                                      Severity: Critical
                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                            removeClass: function( value ) {
        var classes, elem, cur, clazz, j, finalValue,
            proceed = arguments.length === 0 || typeof value === "string" && value,
            i = 0,
            len = this.length;
                                                                                        Severity: Minor
                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                          Function style has 32 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;
        }
                                                                                          Severity: Minor
                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                            jQuery.fn.load = function( url, params, callback ) {
    if ( typeof url !== "string" && _load ) {
        return _load.apply( this, arguments );
    }
                                                                                            Severity: Minor
                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                                  addClass: function( value ) {
        var classes, elem, cur, clazz, j, finalValue,
            proceed = typeof value === "string" && value,
            i = 0,
            len = this.length;
                                                                                              Severity: Minor
                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                                Function handlers has 30 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;
                                                                                                Severity: Minor
                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                                      attr: function( elem, name, value ) {
        var hooks, ret,
            nType = elem.nodeType;

        // don't get/set attributes on text, comment and attribute nodes
                                                                                                  Severity: Minor
                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                                    Function toggleClass has 29 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 );
                                                                                                    Severity: Minor
                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                                      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() {
                                                                                                      Severity: Minor
                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                                            fix: function( event ) {
        if ( event[ jQuery.expando ] ) {
            return event;
        }
                                                                                                        Severity: Minor
                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                                          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 ) {
                                                                                                          Severity: Minor
                                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                                            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 );
                                                                                                            Severity: Minor
                                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                                                      "*": [ function( prop, value ) {
            var tween = this.createTween( prop, value ),
                target = tween.cur(),
                parts = rfxnum.exec( value ),
                unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
                                                                                                              Severity: Minor
                                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                                                    offset: function( options ) {
        if ( arguments.length ) {
            return options === undefined ?
                this :
                this.each(function( i ) {
                                                                                                                Severity: Minor
                                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                                                  Function off has 26 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
            handleObj = types.handleObj;
                                                                                                                  Severity: Minor
                                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

                                                                                                                    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];
                                                                                                                    Severity: Major
                                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 1 hr to fix

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

                                                                                                                      var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
                                                                                                                      Severity: Major
                                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 50 mins to fix

                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                        Open

                                                                                                                                                            if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
                                        return false;
                                    }
                                                                                                                        Severity: Major
                                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                          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 ] );
                                                                                                                          Severity: Major
                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                            Open

                                                                                                                                                for ( conv2 in converters ) {

                        // If conv2 outputs current
                        tmp = conv2.split( " " );
                        if ( tmp[ 1 ] === current ) {
                                                                                                                            Severity: Major
                                                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                              Open

                                                                                                                                                      if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
                            cur += clazz + " ";
                        }
                                                                                                                              Severity: Major
                                                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                Open

                                                                                                                                                        if ( matches[ sel ] === undefined ) {
                            matches[ sel ] = handleObj.needsContext ?
                                jQuery( sel, this ).index( cur ) >= 0 :
                                jQuery.find( sel, this, null, [ cur ] ).length;
                        }
                                                                                                                                Severity: Major
                                                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                  Open

                                                                                                                                                      if ( conv && s[ "throws" ] ) {
                        response = conv( response );
                    } else {
                        try {
                            response = conv( response );
                                                                                                                                  Severity: Major
                                                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                    Open

                                                                                                                                                        if ( !selector ) {
                        push.apply( results, seed );
                        return results;
                    }
                                                                                                                                    Severity: Major
                                                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                      Open

                                                                                                                                                              if ( hasScripts ) {
                            // Support: QtWebKit
                            // jQuery.merge because push.apply(_, arraylike) throws
                            jQuery.merge( scripts, getAll( node, "script" ) );
                        }
                                                                                                                                      Severity: Major
                                                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                        Open

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

                            if ( node.src ) {
                                // Optional AJAX dependency, but won't run scripts if not present
                                                                                                                                        Severity: Major
                                                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

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

                                                                                                                                          function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

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

                                                                                                                                                init: function( elem, options, prop, end, easing, unit ) {
                                                                                                                                            Severity: Minor
                                                                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                              Open

                                                                                                                                                                              if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
                                    // Cache the index of each encountered element
                                    if ( useCache ) {
                                        (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
                                    }
                                                                                                                                              Severity: Major
                                                                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                Open

                                                                                                                                                                            if ( !(unmatched[i] || setMatched[i]) ) {
                                setMatched[i] = pop.call( results );
                            }
                                                                                                                                                Severity: Major
                                                                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                  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 ] );
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                    Open

                                                                                                                                                                        if ( elem && elem.parentNode ) {
                        // Handle the case where IE, Opera, and Webkit return items
                        // by name instead of ID
                        if ( elem.id === m ) {
                            results.push( elem );
                                                                                                                                                    Severity: Major
                                                                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                      Open

                                                                                                                                                                              if ( matches[ sel ] ) {
                            matches.push( handleObj );
                        }
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

                                                                                                                                                                                    if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
                                return true;
                            }
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                          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) );
                        }
                                                                                                                                                          Severity: Major
                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                            Open

                                                                                                                                                                                    if ( (event.result = ret) === false ) {
                            event.preventDefault();
                            event.stopPropagation();
                        }
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                              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
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                Open

                                                                                                                                                                                        while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
                            cur = cur.replace( " " + clazz + " ", " " );
                        }
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                  Open

                                                                                                                                                                                  } else if ( copy !== undefined ) {
                    target[ name ] = copy;
                }
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                    Open

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

                    } else {
                                                                                                                                                                    Severity: Major
                                                                                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                      Open

                                                                                                                                                                                          if ( Expr.relative[ tokens[j].type ] ) {
                        break;
                    }
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                        Open

                                                                                                                                                                                            if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
                        contains( context, elem ) && elem.id === m ) {
                        results.push( elem );
                        return results;
                    }
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 45 mins to fix

                                                                                                                                                                          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 ] ) {
                                                                                                                                                                          Severity: Major
                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 40 mins to fix

                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                            Open

                                                                                                                                                                                if ( support.matchesSelector && documentIsHTML &&
        ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
        ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {

        try {
                                                                                                                                                                            Severity: Major
                                                                                                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 40 mins to fix

                                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                                              Open

                                                                                                                                                                                      if ( s.crossDomain == null ) {
            parts = rurl.exec( s.url.toLowerCase() );
            s.crossDomain = !!( parts &&
                ( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
                    ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
                                                                                                                                                                              Severity: Major
                                                                                                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 40 mins to fix

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

                                                                                                                                                                                        superMatcher = function( seed, context, xml, results, outermost ) {
                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

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

                                                                                                                                                                                      on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

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

                                                                                                                                                                                        remove: function( elem, types, handler, selector, mappedTypes ) {
                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

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

                                                                                                                                                                                      function condense( unmatched, map, filter, context, xml ) {
                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

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

                                                                                                                                                                                        function Tween( elem, options, prop, end, easing ) {
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

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

                                                                                                                                                                                          function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

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

                                                                                                                                                                                                add: function( elem, types, handler, data, selector ) {
                                                                                                                                                                                            Severity: Minor
                                                                                                                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

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

                                                                                                                                                                                                      "CHILD": function( type, what, argument, first, last ) {
                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 35 mins to fix

                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                Open

                                                                                                                                                                                                                        return results;
                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                  Open

                                                                                                                                                                                                              return typeof rootjQuery.ready !== "undefined" ?
                rootjQuery.ready( selector ) :
                // Execute immediately if ready is not present
                selector( jQuery );
                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                    Open

                                                                                                                                                                                                                        return results;
                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                      Open

                                                                                                                                                                                                                      return results;
                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                        Open

                                                                                                                                                                                                                    return ret == null ?
                undefined :
                ret;
                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                          Open

                                                                                                                                                                                                                  return compare & 4 ? -1 : 1;
                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                            Open

                                                                                                                                                                                                                            return this.constructor( context ).find( selector );
                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                            Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                              Open

                                                                                                                                                                                                                      return jQuery.makeArray( selector, this );
                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                              Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                            return sortInput ?
                ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
                0;
                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                  return results;
                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                  Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                        return select( selector.replace( rtrim, "$1" ), context, results, seed );
                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                    Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                  return ret;
                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                      Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                    return this;
                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                        Found in app/bower_components/jquery/dist/jquery.js - About 30 mins to fix

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.event = {

    global: {},

    add: function( elem, types, handler, data, selector ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 mo to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event.js on lines 39..615

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 4817.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Expr = Sizzle.selectors = {

    // Can be adjusted by the user
    cacheLength: 50,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 959..1423

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 3704.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({

    // Counter for holding the number of active queries
    active: 0,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 289..777

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 3046.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          setDocument = Sizzle.setDocument = function( node ) {
    var hasCompare,
        doc = node ? node.ownerDocument || node : preferredDoc,
        parent = doc.defaultView;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 463..823

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 2475.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    text: function( value ) {
        return access( this, function( value ) {
            return value === undefined ?
                jQuery.text( this ) :
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 311..552

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1871.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    // Unique for each copy of jQuery on the page
    expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),

    // Assume jQuery is ready without the ready module
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core.js on lines 189..474

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1661.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    addClass: function( value ) {
        var classes, elem, cur, clazz, j, finalValue,
            proceed = typeof value === "string" && value,
            i = 0,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/classes.js on lines 11..156

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1226.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    clone: function( elem, dataAndEvents, deepDataAndEvents ) {
        var i, l, srcElements, destElements,
            clone = elem.cloneNode( true ),
            inPage = jQuery.contains( elem.ownerDocument, elem );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 147..309

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1223.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({

    Deferred: function( func ) {
        var tuples = [
                // action, add listener, listener list, final state
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/deferred.js on lines 7..146

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1130.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function defaultPrefilter( elem, props, opts ) {
    /* jshint validthis: true */
    var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
        anim = this,
        orig = {},
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 117..249

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1083.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. 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" ?
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/callbacks.js on lines 40..202

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1026.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    fadeTo: function( speed, to, easing, callback ) {

        // show any hidden elements after setting opacity to 0
        return this.filter( isHidden ).css( "opacity", 0 ).show()
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 454..572

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 1018.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Data.prototype = {
    key: function( owner ) {
        // We can accept data for non-element nodes in modern browsers,
        // but we should not, see #8335.
        // Always return the key for a frozen object.
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/data/Data.js on lines 23..178

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 939.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var i,
    support,
    Expr,
    getText,
    isXML,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 13..157

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 934.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    // Add in style property hooks for overriding the default
    // behavior of getting and setting a style property
    cssHooks: {
        opacity: {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 203..335

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 933.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function Animation( elem, properties, options ) {
    var result,
        stopped,
        index = 0,
        length = animationPrefilters.length,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 288..390

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 839.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function Sizzle( selector, context, results, seed ) {
    var match, elem, m, nodeType,
        // QSA vars
        i, groups, old, nid, newContext, newSelector;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 188..295

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 824.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({

    on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
        var origFn, type;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event.js on lines 764..865

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 767.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var rootjQuery,

    // A simple way to check for HTML strings
    // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
    // Strict HTML recognition (#11290: must start with <)
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core/init.js on lines 9..113

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 687.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    offset: function( options ) {
        if ( arguments.length ) {
            return options === undefined ?
                this :
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/offset.js on lines 73..158

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 671.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    attr: function( elem, name, value ) {
        var hooks, ret,
            nType = elem.nodeType;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/attr.js on lines 25..111

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 642.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    data: function( key, value ) {
        var i, name, data,
            elem = this[ 0 ],
            attrs = elem && elem.attributes;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/data.js on lines 76..176

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 625.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
    if ( postFilter && !postFilter[ expando ] ) {
        postFilter = setMatcher( postFilter );
    }
    if ( postFinder && !postFinder[ expando ] ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1614..1705

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 617.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. 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) );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1900..1968

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 616.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. 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,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1762..1859

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 615.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.ajaxTransport(function( options ) {
    var callback;

    // Cross domain only allowed if supported through XMLHttpRequest
    if ( support.cors || xhrSupported && !options.crossDomain ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/xhr.js on lines 37..133

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 605.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. 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
        dataTypes = s.dataTypes.slice();
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 198..287

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 605.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    has: function( target ) {
        var targets = jQuery( target, this ),
            l = targets.length;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/traversing.js on lines 48..126

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 590.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function matcherFromTokens( tokens ) {
    var checkContext, matcher, j,
        len = tokens.length,
        leadingRelative = Expr.relative[ tokens[0].type ],
        implicitRelative = leadingRelative || Expr.relative[" "],
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1707..1760

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 541.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

    var callbackName, overwritten, responseContainer,
        jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
            "url" :
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/jsonp.js on lines 22..87

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 534.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          (function() {
    var pixelPositionVal, boxSizingReliableVal,
        docElem = document.documentElement,
        container = document.createElement( "div" ),
        div = document.createElement( "div" );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/support.js on lines 6..87

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 533.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each({
    parent: function( elem ) {
        var parent = elem.parentNode;
        return parent && parent.nodeType !== 11 ? parent : null;
    },
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/traversing.js on lines 133..197

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 527.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    wrapAll: function( html ) {
        var wrap;

        if ( jQuery.isFunction( html ) ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/wrap.js on lines 7..75

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 519.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    valHooks: {
        option: {
            get: function( elem ) {
                var val = jQuery.find.attr( elem, "value" );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/val.js on lines 72..143

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 516.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn = jQuery.prototype = {
    // The current version of jQuery being used
    jquery: version,

    constructor: jQuery,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core.js on lines 39..122

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 496.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    val: function( value ) {
        var hooks, ret, isFunction,
            elem = this[0];
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/val.js on lines 9..70

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 489.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
    var matched, match, tokens, type,
        soFar, groups, preFilters,
        cached = tokenCache[ selector + " " ];
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1440..1505

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 480.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Tween.prototype = {
    constructor: Tween,
    init: function( elem, options, prop, end, easing, unit ) {
        this.elem = elem;
        this.prop = prop;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects/Tween.js on lines 11..53

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 470.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    queue: function( type, data ) {
        var setter = 2;

        if ( typeof type !== "string" ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/queue.js on lines 74..139

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 468.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var
    fxNow, timerId,
    rfxtypes = /^(?:toggle|show|hide)$/,
    rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ),
    rrun = /queueHooks$/,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 17..72

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 466.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    queue: function( elem, type, data ) {
        var queue;

        if ( elem ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/queue.js on lines 8..72

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 460.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend = jQuery.fn.extend = function() {
    var options, name, src, copy, copyIsArray, clone,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core.js on lines 124..187

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 451.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.offset = {
    setOffset: function( elem, options, i ) {
        var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
            position = jQuery.css( elem, "position" ),
            curElem = jQuery( elem ),
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/offset.js on lines 24..71

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 433.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function showHide( elements, show ) {
    var display, elem, hidden,
        values = [],
        index = 0,
        length = elements.length;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 152..201

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 411.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    find: function( selector ) {
        var i,
            len = this.length,
            ret = [],
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/traversing/findFilter.js on lines 54..98

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 377.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.load = function( url, params, callback ) {
    if ( typeof url !== "string" && _load ) {
        return _load.apply( this, arguments );
    }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/load.js on lines 18..73

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 367.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function addCombinator( matcher, combinator, base ) {
    var dir = combinator.dir,
        checkNonElements = base && dir === "parentNode",
        doneName = done++;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1517..1568

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 358.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. 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,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 422..452

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 356.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Tween.propHooks = {
    _default: {
        get: function( tween ) {
            var result;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects/Tween.js on lines 57..87

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 355.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
    jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
        // margin is only for outerHeight, outerWidth
        jQuery.fn[ funcName ] = function( margin, value ) {
            var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/dimensions.js on lines 8..47

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 354.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    propFix: {
        "for": "htmlFor",
        "class": "className"
    },
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/prop.js on lines 21..65

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 344.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    serialize: function() {
        return jQuery.param( this.serializeArray() );
    },
    serializeArray: function() {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/serialize.js on lines 78..108

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 343.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
    var i = 0,
        len = elems.length,
        bulk = key == null;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core/access.js on lines 7..56

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 339.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function ajaxHandleResponses( s, jqXHR, responses ) {

    var ct, type, finalDataType, firstDataType,
        contents = s.contents,
        dataTypes = s.dataTypes;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 142..193

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 338.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    css: function( name, value ) {
        return access( this, function( elem, name, value ) {
            var styles, len,
                map = {},
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 406..448

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 332.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function curCSS( elem, name, computed ) {
    var width, minWidth, maxWidth, ret,
        style = elem.style;

    computed = computed || getStyles( elem );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/curCSS.js on lines 9..54

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 309.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( !support.focusinBubbles ) {
    jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {

        // Attach a single capturing handler on the document while someone wants focusin/focusout
        var handler = function( event ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event.js on lines 730..762

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 291.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
    var i = extra === ( isBorderBox ? "border" : "content" ) ?
        // If we already have the right measurement, avoid augmentation
        4 :
        // Otherwise initialize for horizontal or vertical properties
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 69..106

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 282.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.param = function( a, traditional ) {
    var prefix,
        s = [],
        add = function( key, value ) {
            // If value is a function, invoke it and return its value
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/serialize.js on lines 45..76

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 279.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function propFilter( props, specialEasing ) {
    var index, name, easing, value, hooks;

    // camelCase, specialEasing and expand cssHook pass
    for ( index in props ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 251..286

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 276.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function cloneCopyEvent( src, dest ) {
    var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;

    if ( dest.nodeType !== 1 ) {
        return;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 89..121

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 274.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function getWidthOrHeight( elem, name, extra ) {

    // Start with offset property, which is equivalent to the border-box value
    var valueIsBorderBox = true,
        val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 108..150

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 262.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.Event = function( src, props ) {
    // Allow instantiation without the 'new' keyword
    if ( !(this instanceof jQuery.Event) ) {
        return new jQuery.Event( src, props );
    }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event.js on lines 623..658

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 243.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    // Is the DOM ready to be used? Set to true once it occurs.
    isReady: false,

    // A counter to track how many items to wait for before
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core/ready.js on lines 17..59

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 228.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function dataAttr( elem, key, data ) {
    var name;

    // If nothing was found internally, try to fetch any
    // data from the HTML5 data-* attribute
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/data.js on lines 23..50

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 224.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          getText = Sizzle.getText = function( elem ) {
    var node,
        ret = "",
        i = 0,
        nodeType = elem.nodeType;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 928..957

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 221.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Sizzle.matchesSelector = function( elem, expr ) {
    // Set document vars if needed
    if ( ( elem.ownerDocument || elem ) !== document ) {
        setDocument( elem );
    }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 829..856

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 220.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function addToPrefiltersOrTransports( structure ) {

    // dataTypeExpression is optional and defaults to "*"
    return function( dataTypeExpression, func ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 63..92

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 219.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.Event.prototype = {
    isDefaultPrevented: returnFalse,
    isPropagationStopped: returnFalse,
    isImmediatePropagationStopped: returnFalse,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event.js on lines 662..696

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 218.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each({
    margin: "",
    padding: "",
    border: "Width"
}, function( prefix, suffix ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 379..404

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 215.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          (function() {
    var input = document.createElement( "input" ),
        select = document.createElement( "select" ),
        opt = select.appendChild( document.createElement( "option" ) );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/support.js on lines 5..31

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 213.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.ajaxTransport( "script", function( s ) {
    // This transport only deals with cross domain requests
    if ( s.crossDomain ) {
        var script, callback;
        return {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/script.js on lines 33..62

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 211.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

    var inspected = {},
        seekingTransport = ( structure === transports );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 95..117

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 208.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.Animation = jQuery.extend( Animation, {

    tweener: function( props, callback ) {
        if ( jQuery.isFunction( props ) ) {
            callback = props;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 392..420

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 208.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function winnow( elements, qualifier, not ) {
    if ( jQuery.isFunction( qualifier ) ) {
        return jQuery.grep( elements, function( elem, i ) {
            /* jshint -W018 */
            return !!qualifier.call( elem, i, elem ) !== not;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/traversing/findFilter.js on lines 11..38

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 205.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          (function() {
    var fragment = document.createDocumentFragment(),
        div = fragment.appendChild( document.createElement( "div" ) ),
        input = document.createElement( "input" );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation/support.js on lines 5..27

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 203.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each({
    mouseenter: "mouseover",
    mouseleave: "mouseout",
    pointerenter: "pointerover",
    pointerleave: "pointerout"
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event.js on lines 700..726

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 202.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function buildParams( prefix, obj, traditional, add ) {
    var name;

    if ( jQuery.isArray( obj ) ) {
        // Serialize array item.
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/serialize.js on lines 15..41

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 202.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
    var i,
        setMatchers = [],
        elementMatchers = [],
        cached = compilerCache[ selector + " " ];
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1861..1889

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 200.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each({
    appendTo: "append",
    prependTo: "prepend",
    insertBefore: "before",
    insertAfter: "after",
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 554..579

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 199.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.parseHTML = function( data, context, keepScripts ) {
    if ( !data || typeof data !== "string" ) {
        return null;
    }
    if ( typeof context === "boolean" ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core/parseHTML.js on lines 10..35

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 198.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each([ "height", "width" ], function( i, name ) {
    jQuery.cssHooks[ name ] = {
        get: function( elem, computed, extra ) {
            if ( computed ) {
                // certain elements can have dimension info if we invisibly show them
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 337..364

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 197.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    dir: function( elem, dir, until ) {
        var matched = [],
            truncate = until !== undefined;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/traversing.js on lines 19..46

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 196.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          try {
    push.apply(
        (arr = slice.call( preferredDoc.childNodes )),
        preferredDoc.childNodes
    );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 160..186

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 193.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Sizzle.uniqueSort = function( results ) {
    var elem,
        duplicates = [],
        j = 0,
        i = 0;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 895..922

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 190.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
    var top = "pageYOffset" === prop;

    jQuery.fn[ method ] = function( val ) {
        return access( this, function( elem, method, val ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/offset.js on lines 161..183

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 188.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    hover: function( fnOver, fnOut ) {
        return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
    },
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event/alias.js on lines 18..37

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 186.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function defaultDisplay( nodeName ) {
    var doc = document,
        display = elemdisplay[ nodeName ];

    if ( !display ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/defaultDisplay.js on lines 37..66

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 181.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Sizzle.attr = function( elem, name ) {
    // Set document vars if needed
    if ( ( elem.ownerDocument || elem ) !== document ) {
        setDocument( elem );
    }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 866..885

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 180.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
    var getter = attrHandle[ name ] || jQuery.find.attr;

    attrHandle[ name ] = function( elem, name, isXML ) {
        var ret, handle;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/attr.js on lines 125..141

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 170.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each([ "radio", "checkbox" ], function() {
    jQuery.valHooks[ this ] = {
        set: function( elem, value ) {
            if ( jQuery.isArray( value ) ) {
                return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/val.js on lines 146..161

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 163.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fx.tick = function() {
    var timer,
        i = 0,
        timers = jQuery.timers;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 598..617

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 159.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.extend({
    hasData: function( elem ) {
        return data_user.hasData( elem ) || data_priv.hasData( elem );
    },
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/data.js on lines 52..74

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 149.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function siblingCheck( a, b ) {
    var cur = b && a,
        diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
            ( ~b.sourceIndex || MAX_NEGATIVE ) -
            ( ~a.sourceIndex || MAX_NEGATIVE );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 367..388

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 149.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.swap = function( elem, options, callback, args ) {
    var ret, name,
        old = {};

    // Remember the old values, and insert the new ones
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/swap.js on lines 6..24

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 143.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.parseXML = function( data ) {
    var xml, tmp;
    if ( !data || typeof data !== "string" ) {
        return null;
    }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/parseXML.js on lines 6..24

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 143.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.filter = function( expr, elems, not ) {
    var elem = elems[ 0 ];

    if ( not ) {
        expr = ":not(" + expr + ")";
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/traversing/findFilter.js on lines 40..52

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 142.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function genFx( type, includeWidth ) {
    var which,
        i = 0,
        attrs = { height: type };
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 83..101

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 140.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function createPositionalPseudo( fn ) {
    return markFunction(function( argument ) {
        argument = +argument;
        return markFunction(function( seed, matches ) {
            var j,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 416..432

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 136.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( !support.attributes || !assert(function( div ) {
    div.innerHTML = "<input/>";
    div.firstChild.setAttribute( "value", "" );
    return div.firstChild.getAttribute( "value" ) === "";
}) ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 2005..2015

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 132.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

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

        readyList = jQuery.Deferred();
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core/ready.js on lines 70..92

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 129.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function condense( unmatched, map, filter, context, xml ) {
    var elem,
        newUnmatched = [],
        i = 0,
        len = unmatched.length,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1593..1612

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 128.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function isArraylike( obj ) {
    var length = obj.length,
        type = jQuery.type( obj );

    if ( type === "function" || jQuery.isWindow( obj ) ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core.js on lines 481..495

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 126.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function actualDisplay( name, doc ) {
    var style,
        elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),

        // getDefaultComputedStyle might be reliably used only on attached element
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/defaultDisplay.js on lines 15..31

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 125.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.delay = function( time, type ) {
    time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
    type = type || "fx";

    return this.queue( type, function( next, hooks ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/queue/delay.js on lines 9..19

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 123.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function ajaxExtend( target, src ) {
    var key, deep,
        flatOptions = jQuery.ajaxSettings.flatOptions || {};

    for ( key in src ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 122..136

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 123.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each( [ "get", "post" ], function( i, method ) {
    jQuery[ method ] = function( url, data, callback, type ) {
        // shift arguments if data argument was omitted
        if ( jQuery.isFunction( data ) ) {
            type = type || callback;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 779..796

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 123.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each({
    slideDown: genFx("show"),
    slideUp: genFx("hide"),
    slideToggle: genFx("toggle"),
    fadeIn: { opacity: "show" },
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 584..595

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 119.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function vendorPropName( style, name ) {

    // shortcut for names that are not vendor prefixed
    if ( name in style ) {
        return name;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 39..59

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 117.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function fixInput( src, dest ) {
    var nodeName = dest.nodeName.toLowerCase();

    // Fails to persist the checked state of a cloned checkbox or radio button.
    if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 134..145

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 113.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each( [ "top", "left" ], function( i, prop ) {
    jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
        function( elem, computed ) {
            if ( computed ) {
                computed = curCSS( elem, prop );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/offset.js on lines 189..201

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 111.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
    var cssFn = jQuery.fn[ name ];
    jQuery.fn[ name ] = function( speed, easing, callback ) {
        return speed == null || typeof speed === "boolean" ?
            cssFn.apply( this, arguments ) :
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 574..581

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 111.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var
    rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
    rtagName = /<([\w:]+)/,
    rhtml = /<|&#?\w+;/,
    rnoInnerhtml = /<(?:script|style|link)/i,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 18..41

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 110.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( !assert(function( div ) {
    div.innerHTML = "<a href='#'></a>";
    return div.firstChild.getAttribute("href") === "#" ;
}) ) {
    addHandle( "type|href|height|width", function( elem, name, isXML ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1992..2001

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 110.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function getAll( context, tag ) {
    var ret = context.getElementsByTagName ? context.getElementsByTagName( tag || "*" ) :
            context.querySelectorAll ? context.querySelectorAll( tag || "*" ) :
            [];
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 123..131

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 105.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function createTween( value, prop, animation ) {
    var tween,
        collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
        index = 0,
        length = collection.length;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 103..115

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 101.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function manipulationTarget( elem, content ) {
    return jQuery.nodeName( elem, "table" ) &&
        jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?

        elem.getElementsByTagName("tbody")[0] ||
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 51..58

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 100.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    prop: function( name, value ) {
        return access( this, jQuery.prop, name, value, arguments.length > 1 );
    },
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/prop.js on lines 9..19

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 99.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function assert( fn ) {
    var div = document.createElement("div");

    try {
        return !!fn( div );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 330..345

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 99.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var
    // swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
    // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
    rdisplayswap = /^(none|table(?!-c[ea]).+)/,
    rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 23..36

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 95.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function createCache() {
    var keys = [];

    function cache( key, value ) {
        // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 303..315

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 95.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var
    // Use the correct document accordingly with window argument (sandbox)
    document = window.document,

    version = "2.1.1",
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core.js on lines 13..37

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 95.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
    "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
    "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {

    // Handle event binding
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/event/alias.js on lines 6..16

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 94.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
    set: function( tween ) {
        if ( tween.elem.nodeType && tween.elem.parentNode ) {
            tween.elem[ tween.prop ] = tween.now;
        }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects/Tween.js on lines 92..98

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 92.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.extend({
    attr: function( name, value ) {
        return access( this, jQuery.attr, name, value, arguments.length > 1 );
    },
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/attr.js on lines 13..23

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 90.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( !assert(function( div ) {
    return div.getAttribute("disabled") == null;
}) ) {
    addHandle( booleans, function( elem, name, isXML ) {
        var val;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 2019..2031

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 88.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( !support.optSelected ) {
    jQuery.propHooks.selected = {
        get: function( elem ) {
            var parent = elem.parentNode;
            if ( parent && parent.parentNode ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/prop.js on lines 69..79

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 83.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function elementMatcher( matchers ) {
    return matchers.length > 1 ?
        function( elem, context, xml ) {
            var i = matchers.length;
            while ( i-- ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1570..1582

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 83.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var
    // Document location
    ajaxLocParts,
    ajaxLocation,
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 12..45

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 81.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.noConflict = function( deep ) {
    if ( window.$ === jQuery ) {
        window.$ = _$;
    }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/exports/global.js on lines 13..23

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 80.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function setGlobalEval( elems, refElements ) {
    var i = 0,
        l = elems.length;

    for ( ; i < l; i++ ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 78..87

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 79.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fx.timer = function( timer ) {
    jQuery.timers.push( timer );
    if ( timer() ) {
        jQuery.fx.start();
    } else {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 619..626

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 78.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.ajaxSetup({
    jsonp: "callback",
    jsonpCallback: function() {
        var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
        this[ callback ] = true;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/jsonp.js on lines 12..19

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 77.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function Data() {
    // Support: Android < 4,
    // Old WebKit does not have Object.preventExtensions/freeze method,
    // return new empty object instead with no [[set]] accessor
    Object.defineProperty( this.cache = {}, 0, {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/data/Data.js on lines 7..18

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 75.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function createOptions( options ) {
    var object = optionsCache[ options ] = {};
    jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
        object[ flag ] = true;
    });
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/callbacks.js on lines 10..16

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 75.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function addGetHookIf( conditionFn, hookFn ) {
    // Define the hook, we'll check on the first run if it's really needed.
    return {
        get: function() {
            if ( conditionFn() ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/addGetHookIf.js on lines 3..20

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 74.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.ajaxPrefilter( "script", function( s ) {
    if ( s.cache === undefined ) {
        s.cache = false;
    }
    if ( s.crossDomain ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/script.js on lines 23..30

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 70.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function setPositiveNumber( elem, value, subtract ) {
    var matches = rnumsplit.exec( value );
    return matches ?
        // Guard against undefined "subtract", e.g., when used as in cssHooks
        Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 61..67

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 70.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function restoreScript( elem ) {
    var match = rscriptTypeMasked.exec( elem.type );

    if ( match ) {
        elem.type = match[ 1 ];
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 65..75

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 70.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          try {
    ajaxLocation = location.href;
} catch( e ) {
    // Use the href attribute of an A element
    // since IE will modify it given document.location
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 49..57

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 70.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.ajaxSetup({
    accepts: {
        script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
    },
    contents: {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/script.js on lines 7..20

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 69.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
    function( elem, computed ) {
        if ( computed ) {
            // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
            // Work around by temporarily setting element display to inline-block
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css.js on lines 367..376

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 68.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          isXML = Sizzle.isXML = function( elem ) {
    // documentElement is verified for cases where it doesn't yet exist
    // (such as loading iframes in IE - #4833)
    var documentElement = elem && (elem.ownerDocument || elem).documentElement;
    return documentElement ? documentElement.nodeName !== "HTML" : false;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 451..456

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 68.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          boolHook = {
    set: function( elem, value, name ) {
        if ( value === false ) {
            // Remove boolean attributes when set to false
            jQuery.removeAttr( elem, name );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/attr.js on lines 114..124

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 67.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function createButtonPseudo( type ) {
    return function( elem ) {
        var name = elem.nodeName.toLowerCase();
        return (name === "input" || name === "button") && elem.type === type;
    };
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 405..410

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 67.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function addHandle( attrs, handler ) {
    var arr = attrs.split("|"),
        i = attrs.length;

    while ( i-- ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 352..359

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 66.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.easing = {
    linear: function( p ) {
        return p;
    },
    swing: function( p ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects/Tween.js on lines 100..107

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 64.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function toSelector( tokens ) {
    var i = 0,
        len = tokens.length,
        selector = "";
    for ( ; i < len; i++ ) {
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1507..1515

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 63.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.expr.filters.animated = function( elem ) {
    return jQuery.grep(jQuery.timers, function( fn ) {
        return elem === fn.elem;
    }).length;
};
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects/animatedSelector.js on lines 7..11

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 62.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.acceptData = function( owner ) {
    // Accepts only:
    //  - Node
    //    - Node.ELEMENT_NODE
    //    - Node.DOCUMENT_NODE
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/data/accepts.js on lines 8..17

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 62.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
    jQuery.fn[ type ] = function( fn ) {
        return this.on( type, fn );
    };
});
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax.js on lines 799..803

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 61.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery._evalUrl = function( url ) {
    return jQuery.ajax({
        url: url,
        type: "GET",
        dataType: "script",
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation/_evalUrl.js on lines 5..14

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 59.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function createInputPseudo( type ) {
    return function( elem ) {
        var name = elem.nodeName.toLowerCase();
        return name === "input" && elem.type === type;
    };
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 394..399

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 59.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function multipleContexts( selector, contexts, results ) {
    var i = 0,
        len = contexts.length;
    for ( ; i < len; i++ ) {
        Sizzle( selector, contexts[i], results );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1584..1591

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 58.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( window.ActiveXObject ) {
    jQuery( window ).on( "unload", function() {
        for ( var key in xhrCallbacks ) {
            xhrCallbacks[ key ]();
        }
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/xhr.js on lines 26..32

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 58.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fx.start = function() {
    if ( !timerId ) {
        timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
    }
};
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 630..634

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 57.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var isHidden = function( elem, el ) {
        // isHidden might be called from jQuery#filter function;
        // in that case, element will be second argument
        elem = el || elem;
        return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/var/isHidden.js on lines 7..12

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 57.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
    Expr.pseudos[ i ] = createInputPseudo( i );
}
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1428..1430

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 56.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
    class2type[ "[object " + name + "]" ] = name.toLowerCase();
});
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core.js on lines 477..479

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 55.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          Sizzle.contains = function( context, elem ) {
    // Set document vars if needed
    if ( ( context.ownerDocument || context ) !== document ) {
        setDocument( context );
    }
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 858..864

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 54.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          var xhrId = 0,
    xhrCallbacks = {},
    xhrSuccessStatus = {
        // file protocol always yields status code 0, assume 200
        0: 200,
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/ajax/xhr.js on lines 13..22

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 53.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          support.sortDetached = assert(function( div1 ) {
    // Should return 1, but returns 4 (following)
    return div1.compareDocumentPosition( document.createElement("div") ) & 1;
});
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1984..1987

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 53.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if ( typeof define === "function" && define.amd ) {
    define( "jquery", [], function() {
        return jQuery;
    });
}
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/exports/amd.js on lines 18..22

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 51.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.expr.filters.hidden = function( elem ) {
    // Support: Opera <= 12.12
    // Opera reports offsetWidths and offsetHeights less than zero on some elements
    return elem.offsetWidth <= 0 && elem.offsetHeight <= 0;
};
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/hiddenVisibleSelectors.js on lines 6..10

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 51.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.each([
    "tabIndex",
    "readOnly",
    "maxLength",
    "cellSpacing",
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/attributes/prop.js on lines 81..94

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 50.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function disableScript( elem ) {
    elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
    return elem;
}
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/manipulation.js on lines 61..64

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 49.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.fn.ready = function( fn ) {
    // Add the callback
    jQuery.ready.promise().done( fn );

    return this;
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core/ready.js on lines 10..15

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 48.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function completed() {
    document.removeEventListener( "DOMContentLoaded", completed, false );
    window.removeEventListener( "load", completed, false );
    jQuery.ready();
}
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/core/ready.js on lines 64..68

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 46.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          jQuery.expr.filters.visible = function( elem ) {
    return !jQuery.expr.filters.hidden( elem );
};
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/css/hiddenVisibleSelectors.js on lines 11..13

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 46.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/sizzle/dist/sizzle.js on lines 1973..1973

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                          function createFxNow() {
    setTimeout(function() {
        fxNow = undefined;
    });
    return ( fxNow = jQuery.now() );
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/jquery/dist/jquery.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                          app/bower_components/jquery/src/effects.js on lines 75..80

                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                          There are no issues that match your filters.

                                                                                                                                                                                                                          Category
                                                                                                                                                                                                                          Status