Sign upLogin

ThibaultMontaufray/Droid-Image

View on GitHub
Star
Project/Droid.Image.UI/Scripts/jquery-3.0.0.js

Summary

Maintainability
F
1 yr
Test Coverage

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

/*!
 * jQuery JavaScript Library v3.0.0
 * https://jquery.com/
 *
 * Includes Sizzle.js
Severity: Major
Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 wks to fix

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

    (function( window ) {

var i,
    support,
    Expr,
    Severity: Major
    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 wk to fix

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

          ajax: function( url, options ) {

        // If url is an object, simulate pre-1.5 signature
        if ( typeof url === "object" ) {
            options = url;
      Severity: Major
      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 day to fix

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

        setDocument = Sizzle.setDocument = function( node ) {
    var hasCompare, subWindow,
        doc = node ? node.ownerDocument || node : preferredDoc;

    // Return early if doc is invalid or already selected
        Severity: Major
        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 day to fix

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

              Deferred: function( func ) {
        var tuples = [

                // action, add listener, callbacks,
                // ... .then handlers, argument index, [final state]
          Severity: Major
          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 7 hrs to fix

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

            function defaultPrefilter( elem, props, opts ) {
    /* jshint validthis: true */
    var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
        isBox = "width" in props || "height" in props,
        anim = this,
            Severity: Major
            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 4 hrs to fix

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

              jQuery.Callbacks = function( options ) {

    // Convert options from String-formatted to Object-formatted if needed
    // (we check in cache first)
    options = typeof options === "string" ?
              Severity: Major
              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 4 hrs to fix

                Function then has 102 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                                then: function( onFulfilled, onRejected, onProgress ) {
                    var maxDepth = 0;
                    function resolve( depth, deferred, handler, special ) {
                        return function() {
                            var that = this,
                Severity: Major
                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 4 hrs to fix

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

                  function Animation( elem, properties, options ) {
    var result,
        stopped,
        index = 0,
        length = Animation.prefilters.length,
                  Severity: Major
                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 3 hrs to fix

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

                        trigger: function( event, data, elem, onlyHandlers ) {

        var i, cur, tmp, bubbleType, ontype, handle, special,
            eventPath = [ elem || document ],
            type = hasOwn.call( event, "type" ) ? event.type : event,
                    Severity: Major
                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 3 hrs to fix

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

                      function Sizzle( selector, context, results, seed ) {
    var m, i, elem, nid, match, groups, newSelector,
        newContext = context && context.ownerDocument,

        // nodeType defaults to 9, since context defaults to document
                      Severity: Major
                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 3 hrs to fix

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

                                "CHILD": function( type, what, argument, first, last ) {
            var simple = type.slice( 0, 3 ) !== "nth",
                forward = type.slice( -4 ) !== "last",
                ofType = what === "of-type";
                        Severity: Major
                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 3 hrs to fix

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

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

                xhr.open(
                          Severity: Major
                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 3 hrs to fix

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

                            function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
    var bySet = setMatchers.length > 0,
        byElement = elementMatchers.length > 0,
        superMatcher = function( seed, context, xml, results, outermost ) {
            var elem, j, matcher,
                            Severity: Major
                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

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

        var handleObjIn, eventHandle, tmp,
            events, t, handleObj,
            special, handlers, type, namespaces, origType,
                              Severity: Major
                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

                                                    function resolve( depth, deferred, handler, special ) {
                        return function() {
                            var that = this,
                                args = arguments,
                                mightThrow = function() {
                                Severity: Major
                                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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;

            // Ignore repeat invocations
                                  Severity: Major
                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

                                    Consider simplifying this complex logical expression.
                                    Open

                                                            if ( forward && useCache ) {

                            // Seek `elem` from a previously-cached index

                            // ...in a gzip-friendly way
                                    Severity: Critical
                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

                                                superMatcher = function( seed, context, xml, results, outermost ) {
            var elem, j, matcher,
                matchedCount = 0,
                i = "0",
                unmatched = seed && [],
                                        Severity: Major
                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

                                          function ajaxConvert( s, response, jqXHR, isSuccess ) {
    var conv2, current, conv, tmp, prev,
        converters = {},

        // Work with a copy of dataTypes in case we need to modify it for conversion
                                          Severity: Major
                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

                                            function domManip( collection, args, callback, ignored ) {

    // Flatten any nested arrays
    args = concat.apply( [], args );
                                            Severity: Major
                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

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

        // HANDLE: $(""), $(null), $(undefined), $(false)
        if ( !selector ) {
                                              Severity: Major
                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

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

        var j, origCount, tmp,
            events, t, handleObj,
            special, handlers, type, namespaces, origType,
                                                Severity: Major
                                                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs to fix

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

                                                  function buildFragment( elems, context, scripts, selection, ignored ) {
    var elem, tmp, tag, wrap, contains, j,
        fragment = context.createDocumentFragment(),
        nodes = [],
        i = 0,
                                                  Severity: Major
                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 ) ) {
                                                    Severity: Critical
                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 2 hrs 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                          function matcherFromTokens( tokens ) {
    var checkContext, matcher, j,
        len = tokens.length,
        leadingRelative = Expr.relative[ tokens[0].type ],
        implicitRelative = leadingRelative || Expr.relative[" "],
                                                          Severity: Minor
                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                data: function( key, value ) {
        var i, name, data,
            elem = this[ 0 ],
            attrs = elem && elem.attributes;
                                                            Severity: Minor
                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

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

        if ( !arguments.length ) {
                                                              Severity: Minor
                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                function addCombinator( matcher, combinator, base ) {
    var dir = combinator.dir,
        skip = combinator.next,
        key = skip || dir,
        checkNonElements = base && key === "parentNode",
                                                                Severity: Minor
                                                                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                  jQuery.extend = jQuery.fn.extend = function() {
    var options, name, src, copy, copyIsArray, clone,
        target = arguments[ 0 ] || {},
        i = 1,
        length = arguments.length,
                                                                  Severity: Minor
                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                        stop: function( type, clearQueue, gotoEnd ) {
        var stopQueue = function( hooks ) {
            var stop = hooks.stop;
            delete hooks.stop;
            stop( gotoEnd );
                                                                    Severity: Minor
                                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                      function on( elem, types, selector, data, fn, one ) {
    var origFn, type;

    // Types can be a map of types/handlers
    if ( typeof types === "object" ) {
                                                                      Severity: Minor
                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                            toggleClass: function( value, stateVal ) {
        var type = typeof value;

        if ( typeof stateVal === "boolean" && type === "string" ) {
            return stateVal ? this.addClass( value ) : this.removeClass( value );
                                                                        Severity: Minor
                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                          var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
    var i = 0,
        len = elems.length,
        bulk = key == null;
                                                                          Severity: Minor
                                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                dispatch: function( nativeEvent ) {

        // Make a writable jQuery.Event from the native event object
        var event = jQuery.event.fix( nativeEvent );
                                                                            Severity: Minor
                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                                mightThrow = function() {
                                    var returned, then;

                                    // Support: Promises/A+ section 2.3.3.3.3
                                    // https://promisesaplus.com/#point-59
                                                                                Severity: Minor
                                                                                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                      style: function( elem, name, value, extra ) {

        // Don't set styles on text and comment nodes
        if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
            return;
                                                                                  Severity: Minor
                                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                      function adjustCSS( elem, prop, valueParts, tween ) {
    var adjusted,
        scale = 1,
        maxIterations = 20,
        currentValue = tween ?
                                                                                      Severity: Minor
                                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

                                                                                        Consider simplifying this complex logical expression.
                                                                                        Open

                                                                                            if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {

        // Trust units reported by jQuery.css
        unit = unit || initialInUnit[ 3 ];
                                                                                        Severity: Critical
                                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                          function showHide( elements, show ) {
    var display, elem,
        values = [],
        index = 0,
        length = elements.length;
                                                                                          Severity: Minor
                                                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                            jQuery.fn.load = function( url, params, callback ) {
    var selector, type, response,
        self = this,
        off = url.indexOf( " " );
                                                                                            Severity: Minor
                                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

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

        if ( jQuery.isFunction( value ) ) {
                                                                                              Severity: Minor
                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                    handlers: function( event, handlers ) {
        var i, matches, sel, handleObj,
            handlerQueue = [],
            delegateCount = handlers.delegateCount,
            cur = event.target;
                                                                                                Severity: Minor
                                                                                                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

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

        // Don't get/set attributes on text, comment and attribute nodes
                                                                                                  Severity: Minor
                                                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                        off: function( types, selector, fn ) {
        var handleObj, type;
        if ( types && types.preventDefault && types.handleObj ) {

            // ( event )  dispatched jQuery.Event
                                                                                                    Severity: Minor
                                                                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                      function getWidthOrHeight( elem, name, extra ) {

    // Start with offset property, which is equivalent to the border-box value
    var val,
        valueIsBorderBox = true,
                                                                                                      Severity: Minor
                                                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                          jQuery.parseHTML = function( data, context, keepScripts ) {
    if ( typeof data !== "string" ) {
        return [];
    }
    if ( typeof context === "boolean" ) {
                                                                                                          Severity: Minor
                                                                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

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

        if ( jQuery.isFunction( value ) ) {
                                                                                                            Severity: Minor
                                                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                                      offset: function( options ) {

        // Preserve chaining for setter
        if ( arguments.length ) {
            return options === undefined ?
                                                                                                                  Severity: Minor
                                                                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                                        when: function( singleValue ) {
        var

            // count of uncompleted subordinates
            remaining = arguments.length,
                                                                                                                    Severity: Minor
                                                                                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                                      jQuery.speed = function( speed, easing, fn ) {
    var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
        complete: fn || !fn && easing ||
            jQuery.isFunction( speed ) && speed,
        duration: speed,
                                                                                                                      Severity: Minor
                                                                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

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

        if ( cache === undefined ) {
                                                                                                                        Severity: Minor
                                                                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                            Open

                                                                                                                                if ( support.matchesSelector && documentIsHTML &&
        !compilerCache[ expr + " " ] &&
        ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
        ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
                                                                                                                            Severity: Major
                                                                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 1 hr to fix

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

                                                                                                                              var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
                                                                                                                              Severity: Major
                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 50 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

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

                                                                                                                                    function on( elem, types, selector, data, fn, one ) {
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                      Open

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

                // Class selector
                                                                                                                                      Severity: Major
                                                                                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                        Open

                                                                                                                                                        } else if ( copy !== undefined ) {
                    target[ name ] = copy;
                }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                          Open

                                                                                                                                                              if ( (nid = context.getAttribute( "id" )) ) {
                        nid = nid.replace( rcssescape, fcssescape );
                    } else {
                        context.setAttribute( "id", (nid = expando) );
                    }
                                                                                                                                          Severity: Major
                                                                                                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                              Open

                                                                                                                                                                  if ( nodeType === 9 ) {
                        if ( (elem = context.getElementById( m )) ) {

                            // Support: IE, Opera, Webkit
                            // TODO: identify versions
                                                                                                                                              Severity: Major
                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                  Open

                                                                                                                                                                      if ( restoreDisplay == null ) {
                        display = style.display;
                        restoreDisplay = display === "none" ? "" : display;
                    }
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

                                                                                                                                                                                if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
                            cur += clazz + " ";
                        }
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                            Open

                                                                                                                                                                                    if ( matches[ sel ] ) {
                            matches.push( handleObj );
                        }
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                  Open

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

                        if ( node.src ) {
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                      Open

                                                                                                                                                                                          while ( i-- ) {
                        groups[i] = "#" + nid + " " + toSelector( groups[i] );
                    }
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                        Open

                                                                                                                                                                                                if ( nid === expando ) {
                            context.removeAttribute( "id" );
                        }
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                          Open

                                                                                                                                                                                              if ( hasScripts ) {

                        // Support: Android <=4.0 only, PhantomJS 1 only
                        // push.apply(_, arraylike) throws on ancient WebKit
                        jQuery.merge( scripts, getAll( node, "script" ) );
                                                                                                                                                                          Severity: Major
                                                                                                                                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                            Open

                                                                                                                                                                                                    while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
                            cur = cur.replace( " " + clazz + " ", " " );
                        }
                                                                                                                                                                            Severity: Major
                                                                                                                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                              Open

                                                                                                                                                                                                                  if ( ( ofType ?
                                        node.nodeName.toLowerCase() === name :
                                        node.nodeType === 1 ) &&
                                        ++diff ) {
                                                                                                                                                                              Severity: Major
                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 ) > -1 :
                                jQuery.find( sel, this, null, [ cur ] ).length;
                        }
                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 45 mins to fix

                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                        Open

                                                                                                                                                                                                            if ( Expr.relative[ tokens[j].type ] ) {
                        break;
                    }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 40 mins to fix

                                                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                                                              Open

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

            for ( ; cur !== this; cur = cur.parentNode || this ) {
                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 35 mins to fix

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

                                                                                                                                                                                                          function buildFragment( elems, context, scripts, selection, ignored ) {
                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 35 mins to fix

                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                        return results;
                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                          return jQuery.makeArray( selector, this );
                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                return ret;
                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                  return value;
                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                              return results;
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                    return compare & 4 ? -1 : 1;
                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                          return this;
                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                        return elem[ name ];
                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                          return ret == null ? undefined : ret;
                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                  Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                        return results;
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                  return sortInput ?
                ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
                0;
                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                      Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                    return root.ready !== undefined ?
                root.ready( selector ) :

                // Execute immediately if ready is not present
                selector( jQuery );
                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                        Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                    return rect;
                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                            Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js - About 30 mins to fix

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

                                                                                                                                                                                                                                              var Sizzle =
/*!
 * Sizzle CSS Selector Engine v2.3.0
 * https://sizzlejs.com/
 *
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 mos to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 541..2739

                                                                                                                                                                                                                                              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 15109.

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

    global: {},

    add: function( elem, types, handler, data, selector ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4851..5245

                                                                                                                                                                                                                                              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 3037.

                                                                                                                                                                                                                                              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 = [
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3431..3769

                                                                                                                                                                                                                                              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 1823.

                                                                                                                                                                                                                                              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, "" ),
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 259..507

                                                                                                                                                                                                                                              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 1470.

                                                                                                                                                                                                                                              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.event, {

    trigger: function( event, data, elem, onlyHandlers ) {

        var i, cur, tmp, bubbleType, ontype, handle, special,
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7126..7278

                                                                                                                                                                                                                                              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 1246.

                                                                                                                                                                                                                                              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, curValue, clazz, j, finalValue,
            i = 0;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6782..6943

                                                                                                                                                                                                                                              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 1194.

                                                                                                                                                                                                                                              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( {
    detach: function( selector ) {
        return remove( this, selector, true );
    },
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5757..5895

                                                                                                                                                                                                                                              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 1038.

                                                                                                                                                                                                                                              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( isHiddenWithinTree ).css( "opacity", 0 ).show()
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6672..6790

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3197..3389

                                                                                                                                                                                                                                              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 987.

                                                                                                                                                                                                                                              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: {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6231..6371

                                                                                                                                                                                                                                              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 921.

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

    cache: function( owner ) {

        // Check if the owner object already has a cache
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3946..4089

                                                                                                                                                                                                                                              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 747.

                                                                                                                                                                                                                                              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( {
    offset: function( options ) {

        // Preserve chaining for setter
        if ( arguments.length ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7678..7784

                                                                                                                                                                                                                                              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 691.

                                                                                                                                                                                                                                              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 domManip( collection, args, callback, ignored ) {

    // Flatten any nested arrays
    args = concat.apply( [], args );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5564..5652

                                                                                                                                                                                                                                              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 644.

                                                                                                                                                                                                                                              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 buildFragment( elems, context, scripts, selection, ignored ) {
    var elem, tmp, tag, wrap, contains, j,
        fragment = context.createDocumentFragment(),
        nodes = [],
        i = 0,
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4647..4734

                                                                                                                                                                                                                                              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 624.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 2886..2991

                                                                                                                                                                                                                                              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 621.

                                                                                                                                                                                                                                              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( {
    htmlPrefilter: function( html ) {
        return html.replace( rxhtmlTag, "<$1></$2>" );
    },
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5675..5755

                                                                                                                                                                                                                                              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 606.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3010..3089

                                                                                                                                                                                                                                              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 587.

                                                                                                                                                                                                                                              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 ret, hooks,
            nType = elem.nodeType;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6541..6615

                                                                                                                                                                                                                                              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 551.

                                                                                                                                                                                                                                              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 ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7020..7100

                                                                                                                                                                                                                                              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 513.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4163..4244

                                                                                                                                                                                                                                              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 500.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3096..3161

                                                                                                                                                                                                                                              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 495.

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              jQuery.fn.extend( {
    val: function( value ) {
        var hooks, ret, isFunction,
            elem = this[ 0 ];
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7293..7354
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6951..7018

                                                                                                                                                                                                                                              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

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

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

        if ( this[ 0 ] ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7479..7543

                                                                                                                                                                                                                                              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 487.

                                                                                                                                                                                                                                              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,
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 110..188

                                                                                                                                                                                                                                              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 469.

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

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

        if ( typeof type !== "string" ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 3923..3988
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4313..4379

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

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

        if ( elem ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 3857..3921
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4247..4311

                                                                                                                                                                                                                                              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 3 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 177..240
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 190..257

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              ( function() {

    // Executing both pixelPosition & boxSizingReliable tests require only one layout
    // so they're executed at the same time to save the second computation.
    function computeStyleTests() {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5943..6018

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7626..7676

                                                                                                                                                                                                                                              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 447.

                                                                                                                                                                                                                                              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 adjustCSS( elem, prop, valueParts, tween ) {
    var adjusted,
        scale = 1,
        maxIterations = 20,
        currentValue = tween ?
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4429..4485

                                                                                                                                                                                                                                              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 430.

                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7834..7877

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              function on( elem, types, selector, data, fn, one ) {
    var origFn, type;

    // Types can be a map of types/handlers
    if ( typeof types === "object" ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4786..4845

                                                                                                                                                                                                                                              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 373.

                                                                                                                                                                                                                                              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( {
    prop: function( elem, name, value ) {
        var ret, hooks,
            nType = elem.nodeType;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6670..6728

                                                                                                                                                                                                                                              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 373.

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              jQuery.fn.extend( {
    serialize: function() {
        return jQuery.param( this.serializeArray() );
    },
    serializeArray: function() {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8480..8510
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7445..7476

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              jQuery.fn.extend( {
    find: function( selector ) {
        var i, ret,
            len = this.length,
            self = this;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 2837..2879

                                                                                                                                                                                                                                              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 342.

                                                                                                                                                                                                                                              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( {
    altKey: true,
    bubbles: true,
    cancelable: true,
    changedTouches: true,
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5345..5391

                                                                                                                                                                                                                                              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 340.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7652..7703

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
    var i = 0,
        len = elems.length,
        bulk = key == null;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3870..3924

                                                                                                                                                                                                                                              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 331.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5255..5302

                                                                                                                                                                                                                                              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 330.

                                                                                                                                                                                                                                              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,
        values = [],
        index = 0,
        length = elements.length;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4513..4559

                                                                                                                                                                                                                                              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 322.

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

    on: function( types, selector, data, fn ) {
        return on( this, types, selector, data, fn );
    },
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5429..5473

                                                                                                                                                                                                                                              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 319.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6021..6065

                                                                                                                                                                                                                                              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 317.

                                                                                                                                                                                                                                              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.parseHTML = function( data, context, keepScripts ) {
    if ( typeof data !== "string" ) {
        return [];
    }
    if ( typeof context === "boolean" ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7572..7616

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              jQuery.each( [ "height", "width" ], function( i, name ) {
    jQuery.cssHooks[ name ] = {
        get: function( elem, computed, extra ) {
            if ( computed ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6373..6418

                                                                                                                                                                                                                                              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 300.

                                                                                                                                                                                                                                              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.focusin ) {
    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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7329..7361

                                                                                                                                                                                                                                              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 296.

                                                                                                                                                                                                                                              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 val,
        valueIsBorderBox = true,
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6179..6229

                                                                                                                                                                                                                                              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 286.

                                                                                                                                                                                                                                              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 3 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 :
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 5742..5779
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6135..6177

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5516..5548

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6469..6504

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                  run: function( percent ) {
        var eased,
            hooks = Tween.propHooks[ this.prop ];

        if ( this.options.duration ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6147..6170

                                                                                                                                                                                                                                              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 253.

                                                                                                                                                                                                                                              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 = {
    constructor: jQuery.Event,
    isDefaultPrevented: returnFalse,
    isPropagationStopped: returnFalse,
    isImmediatePropagationStopped: returnFalse,
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5306..5342

                                                                                                                                                                                                                                              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 237.

                                                                                                                                                                                                                                              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, valueOrFunction ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7410..7443

                                                                                                                                                                                                                                              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 232.

                                                                                                                                                                                                                                              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 3 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 3701..3728
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4109..4137

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 2794..2821

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7573..7602

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              jQuery.each( {
    margin: "",
    padding: "",
    border: "Width"
}, function( prefix, suffix ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6052..6077
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6434..6459

                                                                                                                                                                                                                                              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 buildParams( prefix, obj, traditional, add ) {
    var name;

    if ( jQuery.isArray( obj ) ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7370..7406

                                                                                                                                                                                                                                              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 210.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7605..7627

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              jQuery.each( {
    mouseenter: "mouseover",
    mouseleave: "mouseout",
    pointerenter: "pointerover",
    pointerleave: "pointerout"
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5401..5427

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4737..4760

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              jQuery.each( {
    appendTo: "append",
    prependTo: "prepend",
    insertBefore: "before",
    insertAfter: "after",
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 5423..5448
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5897..5922

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                          if ( isSuccess ) {

                // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
                if ( s.ifModified ) {
                    modified = jqXHR.getResponseHeader( "Last-Modified" );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8204..8243

                                                                                                                                                                                                                                              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 194.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6461..6484

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7787..7809

                                                                                                                                                                                                                                              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 189.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6502..6523

                                                                                                                                                                                                                                              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 179.

                                                                                                                                                                                                                                              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,
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3798..3835

                                                                                                                                                                                                                                              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 177.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6631..6650

                                                                                                                                                                                                                                              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 175.

                                                                                                                                                                                                                                              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 ( !conv ) {
                    for ( conv2 in converters ) {

                        // If conv2 outputs current
                        tmp = conv2.split( " " );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7752..7776

                                                                                                                                                                                                                                              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 171.

                                                                                                                                                                                                                                              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 adoptValue( value, resolve, reject ) {
    var method;

    try {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3399..3429

                                                                                                                                                                                                                                              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 171.

                                                                                                                                                                                                                                              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 ) > -1 );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7103..7116

                                                                                                                                                                                                                                              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 167.

                                                                                                                                                                                                                                              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 remove( elem, selector, keepData ) {
    var node,
        nodes = selector ? jQuery.filter( selector, elem ) : elem,
        i = 0;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5654..5673

                                                                                                                                                                                                                                              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 165.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6816..6835

                                                                                                                                                                                                                                              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.fn.extend( {
    show: function() {
        return showHide( this, true );
    },
    hide: function() {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4561..4581

                                                                                                                                                                                                                                              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 157.

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              jQuery.extend( {
    hasData: function( elem ) {
        return dataUser.hasData( elem ) || dataPriv.hasData( elem );
    },
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 5 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 3730..3752
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4139..4161

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              if ( !support.optSelected ) {
    jQuery.propHooks.selected = {
        get: function( elem ) {
            var parent = elem.parentNode;
            if ( parent && parent.parentNode ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6736..6756

                                                                                                                                                                                                                                              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 145.

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              jQuery.filter = function( expr, elems, not ) {
    var elem = elems[ 0 ];

    if ( not ) {
        expr = ":not(" + expr + ")";
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 5 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 2636..2648
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 2823..2835

                                                                                                                                                                                                                                              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 getDefaultDisplay( elem ) {
    var temp,
        doc = elem.ownerDocument,
        nodeName = elem.nodeName,
        display = defaultDisplayMap[ nodeName ];
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4490..4511

                                                                                                                                                                                                                                              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 141.

                                                                                                                                                                                                                                              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 genFx( type, includeWidth ) {
    var which,
        i = 0,
        attrs = { height: type };
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6301..6319

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              var swap = function( elem, options, callback, args ) {
    var ret, name,
        old = {};

    // Remember the old values, and insert the new ones
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4406..4424

                                                                                                                                                                                                                                              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 137.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6489..6499

                                                                                                                                                                                                                                              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 131.

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

    // Support: real iOS 8.2 only (not reproducible in simulator)
    // `in` check used to prevent JIT error (gh-2145)
    // hasOwn isn't used here due to false negatives
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 525..540

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7632..7646

                                                                                                                                                                                                                                              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( [ "top", "left" ], function( i, prop ) {
    jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
        function( elem, computed ) {
            if ( computed ) {
                computed = curCSS( elem, prop );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7817..7830

                                                                                                                                                                                                                                              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 121.

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

    // Support: IE <=9 - 11 only
    // Use typeof to avoid zero-argument method invocation on host objects (#15151)
    var ret = typeof context.getElementsByTagName !== "undefined" ?
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4614..4627

                                                                                                                                                                                                                                              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 120.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6802..6813

                                                                                                                                                                                                                                              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( global, factory ) {

    "use strict";

    if ( typeof module === "object" && typeof module.exports === "object" ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 14..7932

                                                                                                                                                                                                                                              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 115.

                                                                                                                                                                                                                                              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 3 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 5003..5014
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5551..5562

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              var dir = function( elem, dir, until ) {
    var matched = [],
        truncate = until !== undefined;

    while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 2756..2769

                                                                                                                                                                                                                                              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 112.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6792..6799

                                                                                                                                                                                                                                              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.fn.extend( {

    trigger: function( type, data ) {
        return this.each( function() {
            jQuery.event.trigger( type, data, this );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7280..7293

                                                                                                                                                                                                                                              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 109.

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

    // Shortcut for names that are not vendor prefixed
    if ( name in emptyStyle ) {
        return name;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6104..6121

                                                                                                                                                                                                                                              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 108.

                                                                                                                                                                                                                                              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.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
    function( elem, computed ) {
        if ( computed ) {
            return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
                elem.getBoundingClientRect().left -
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6420..6431

                                                                                                                                                                                                                                              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 106.

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                      jqXHR.setRequestHeader(
            "Accept",
            s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
                s.accepts[ s.dataTypes[ 0 ] ] +
                    ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8104..8109

                                                                                                                                                                                                                                              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 104.

                                                                                                                                                                                                                                              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 isHiddenWithinTree = function( elem, el ) {

        // isHiddenWithinTree might be called from jQuery#filter function;
        // in that case, element will be second argument
        elem = el || elem;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4387..4404

                                                                                                                                                                                                                                              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 102.

                                                                                                                                                                                                                                              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 ( document.readyState === "complete" ||
    ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {

    // Handle it asynchronously to allow scripts the opportunity to delay ready
    window.setTimeout( jQuery.ready );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3850..3863

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                      if ( jsonProp ) {
            s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
        } else if ( s.jsonp !== false ) {
            s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
        }
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8736..8740

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                  var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
        complete: fn || !fn && easing ||
            jQuery.isFunction( speed ) && speed,
        duration: speed,
        easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6641..6646

                                                                                                                                                                                                                                              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.Deferred.exceptionHook = function( error, stack ) {

    // Support: IE 8 - 9 only
    // Console exists when dev tools are open, which can happen at any time
    if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3776..3783

                                                                                                                                                                                                                                              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 3 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7049..7059
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6658..6668

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                  if ( opts.overflow ) {
        style.overflow = "hidden";
        anim.always( function() {
            style.overflow = opts.overflow[ 0 ];
            style.overflowX = opts.overflow[ 1 ];
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6391..6398

                                                                                                                                                                                                                                              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 97.

                                                                                                                                                                                                                                              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 resize scroll click dblclick " +
    "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
    "change select submit keydown keypress keyup contextmenu" ).split( " " ),
    function( i, name ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7296..7307

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6210..6216

                                                                                                                                                                                                                                              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 3 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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6914..6924
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6529..6539

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                      if ( s.ifModified ) {
            if ( jQuery.lastModified[ cacheURL ] ) {
                jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
            }
            if ( jQuery.etag[ cacheURL ] ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8089..8096

                                                                                                                                                                                                                                              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 85.

                                                                                                                                                                                                                                              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 ( completed ) {
                        if ( !responseHeaders ) {
                            responseHeaders = {};
                            while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
                                responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7944..7952

                                                                                                                                                                                                                                              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 84.

                                                                                                                                                                                                                                              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
    version = "3.0.0",

    // Define a local copy of jQuery
    jQuery = function( selector, context ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 86..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 84.

                                                                                                                                                                                                                                              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 ) {
    if ( jQuery.nodeName( elem, "table" ) &&
        jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {

        return elem.getElementsByTagName( "tbody" )[ 0 ] || elem;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5489..5497

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              jQuery.noConflict = function( deep ) {
    if ( window.$ === jQuery ) {
        window.$ = _$;
    }
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 9166..9176
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7911..7921

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                      if ( hooks.unqueued == null ) {
            hooks.unqueued = 0;
            oldfire = hooks.empty.fire;
            hooks.empty.fire = function() {
                if ( !hooks.unqueued ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6347..6355

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              function setGlobalEval( elems, refElements ) {
    var i = 0,
        l = elems.length;

    for ( ; i < l; i++ ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 4947..4956
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4631..4642

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              support.createHTMLDocument = ( function() {
    var body = document.implementation.createHTMLDocument( "" ).body;
    body.innerHTML = "<form></form><form></form>";
    return body.childNodes.length === 2;
} )();
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7561..7565

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                  return animation.progress( animation.opts.progress )
        .done( animation.opts.done, animation.opts.complete )
        .fail( animation.opts.fail )
        .always( animation.opts.always );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6604..6607

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6837..6844

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                  opt.complete = function() {
        if ( jQuery.isFunction( opt.old ) ) {
            opt.old.call( this );
        }
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6659..6667

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8709..8716

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                          createTween: function( prop, end ) {
                var tween = jQuery.Tween( elem, animation.opts, prop, end,
                        animation.opts.specialEasing[ prop ] || animation.opts.easing );
                animation.tweens.push( tween );
                return tween;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6549..6554

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              var siblings = function( n, elem ) {
    var matched = [];

    for ( ; n; n = n.nextSibling ) {
        if ( n.nodeType === 1 && n !== elem ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 2772..2782

                                                                                                                                                                                                                                              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 76.

                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6088..6101

                                                                                                                                                                                                                                              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 76.

                                                                                                                                                                                                                                              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 DOMEval( code, doc ) {
        doc = doc || document;

        var script = doc.createElement( "script" );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 76..83

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              function setPositiveNumber( elem, value, subtract ) {

    // Any relative (+/-) values have already been
    // normalized at this point
    var matches = rcssNum.exec( value );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6123..6133

                                                                                                                                                                                                                                              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 73.

                                                                                                                                                                                                                                              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() {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6068..6085

                                                                                                                                                                                                                                              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 73.

                                                                                                                                                                                                                                              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 wrapMap = {

    // Support: IE <=9 only
    option: [ 1, "<select multiple='multiple'>", "</select>" ],
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 4591..4605

                                                                                                                                                                                                                                              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 72.

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                      opt.duration = typeof opt.duration === "number" ?
            opt.duration : opt.duration in jQuery.fx.speeds ?
                jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6648..6649

                                                                                                                                                                                                                                              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 71.

                                                                                                                                                                                                                                              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 Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8661..8668

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                  cur: function() {
        var hooks = Tween.propHooks[ this.prop ];

        return hooks && hooks.get ?
            hooks.get( this ) :
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6140..6146

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              var getStyles = function( elem ) {

        // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
        // IE throws on elements created in popups
        // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5927..5939

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              function restoreScript( elem ) {
    var match = rscriptTypeMasked.exec( elem.type );

    if ( match ) {
        elem.type = match[ 1 ];
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5504..5514

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              boolHook = {
    set: function( elem, value, name ) {
        if ( value === false ) {

            // Remove boolean attributes when set to false
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7015..7025
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6618..6629

                                                                                                                                                                                                                                              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 createOptions( options ) {
    var object = {};
    jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
        object[ flag ] = true;
    } );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3167..3173

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                      if ( s.data && s.processData && typeof s.data !== "string" ) {
            s.data = jQuery.param( s.data, s.traditional );
        }
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8036..8038

                                                                                                                                                                                                                                              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 65.

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                              script = jQuery( "<script>" ).prop( {
                    charset: s.scriptCharset,
                    src: s.url
                } ).on(
                    "load error",
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8677..8690

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                  if ( jQuery.isFunction( params ) ) {

        // We assume that it's the callback
        callback = params;
        params = undefined;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8841..8850

                                                                                                                                                                                                                                              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.expr.pseudos.animated = function( elem ) {
    return jQuery.grep( jQuery.timers, function( fn ) {
        return elem === fn.elem;
    } ).length;
};
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8886..8890

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                  if ( conv && s.throws ) {
                        response = conv( response );
                    } else {
                        try {
                            response = conv( response );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7782..7790

                                                                                                                                                                                                                                              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.each( [
    "ajaxStart",
    "ajaxStop",
    "ajaxComplete",
    "ajaxError",
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8309..8313

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                          anim.always( function() {
                hooks.unqueued--;
                if ( !jQuery.queue( elem, "fx" ).length ) {
                    hooks.empty.fire();
                }
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6361..6366

                                                                                                                                                                                                                                              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 60.

                                                                                                                                                                                                                                              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 ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
            jqXHR.setRequestHeader( "Content-Type", s.contentType );
        }
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8099..8101

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              jQuery.expr.pseudos.visible = function( elem ) {
    return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
};
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7549..7551

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              var acceptData = function( owner ) {

    // Accepts only:
    //  - Node
    //    - Node.ELEMENT_NODE
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3925..3935

                                                                                                                                                                                                                                              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 Symbol".split( " " ),
function( i, name ) {
    class2type[ "[object " + name + "]" ] = name.toLowerCase();
} );
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 520..523

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                          if ( fireGlobals ) {
                globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );

                // Handle the global AJAX counter
                if ( !( --jQuery.active ) ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8268..8274

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                  undelegate: function( selector, types, fn ) {

        // ( namespace ) or ( selector, types [, fn] )
        return arguments.length === 1 ?
            this.off( selector, "**" ) :
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7480..7483

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                      s.converters[ "script json" ] = function() {
            if ( !responseContainer ) {
                jQuery.error( callbackName + " was not called" );
            }
            return responseContainer[ 0 ];
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8743..8748

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                              try {

                    // Do send the request (this may raise an exception)
                    xhr.send( options.hasContent && options.data || null );
                } catch ( e ) {
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8621..8629

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                              abort: function( statusText ) {
                    var finalText = statusText || strAbort;
                    if ( transport ) {
                        transport.abort( finalText );
                    }
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7997..8004

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                  ajaxSetup: function( target, settings ) {
        return settings ?

            // Building a settings object
            ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7878..7886

                                                                                                                                                                                                                                              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 52.

                                                                                                                                                                                                                                              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 ( dataTypes[ 1 ] ) {
        for ( conv in s.converters ) {
            converters[ conv.toLowerCase() ] = s.converters[ conv ];
        }
    }
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7715..7719

                                                                                                                                                                                                                                              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 52.

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              if ( typeof define === "function" && define.amd ) {
    define( "jquery", [], function() {
        return jQuery;
    } );
}
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 9150..9154
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7893..7897

                                                                                                                                                                                                                                              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.fn.extend( {
    hover: function( fnOver, fnOut ) {
        return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
    }
} );
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7309..7313

                                                                                                                                                                                                                                              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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                              jQuery.each( [
    "tabIndex",
    "readOnly",
    "maxLength",
    "cellSpacing",
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 45 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7121..7134
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 6758..6771

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                  jQuery.fx.timer(
        jQuery.extend( tick, {
            elem: elem,
            anim: animation,
            queue: animation.opts.queue
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6595..6601

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              function completed() {
    document.removeEventListener( "DOMContentLoaded", completed );
    window.removeEventListener( "load", completed );
    jQuery.ready();
}
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 3840..3844

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              function disableScript( elem ) {
    elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
    return elem;
}
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 40 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 4930..4933
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 5500..5503

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                              if ( typeof Symbol === "function" ) {
    jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
}
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 514..516

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                          self.html( selector ?

                // If a selector was specified, locate the right elements in a dummy div
                // Exclude scripts to avoid IE 'Permission Denied' errors
                jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8866..8873

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                      callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
            s.jsonpCallback() :
            s.jsonpCallback;
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8731..8733

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                          if ( isSuccess ) {
                deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
            } else {
                deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
            }
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8250..8254

                                                                                                                                                                                                                                              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 47.

                                                                                                                                                                                                                                              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 ( s[ callbackName ] ) {

                // Make sure that re-using the options doesn't screw things around
                s.jsonpCallback = originalSettings.jsonpCallback;
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8765..8771

                                                                                                                                                                                                                                              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 47.

                                                                                                                                                                                                                                              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 ( options.xhrFields ) {
                    for ( i in options.xhrFields ) {
                        xhr[ i ] = options.xhrFields[ i ];
                    }
                }
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8557..8561

                                                                                                                                                                                                                                              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 47.

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                          } else if ( tween.elem.nodeType === 1 &&
                ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
                    jQuery.cssHooks[ tween.prop ] ) ) {
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6198..6198

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                              jQuery.expr.pseudos.hidden = function( elem ) {
    return !jQuery.expr.pseudos.visible( elem );
};
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 8404..8406
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-3.0.0.slim.js on lines 7546..7548

                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                  for ( ; index < length; index++ ) {
        if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {

            // We're done with this property
            return tween;
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 6326..6332

                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                      converters: {

            // Convert anything to text
            "* text": String,
                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                              Found in Project/Droid.Image.UI/Scripts/jquery-3.0.0.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                              Project/Droid.Image.UI/Scripts/jquery-2.1.1.js on lines 7850..7863

                                                                                                                                                                                                                                              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