Sign upLogin

webcol/Calima

View on GitHub
Star
public_/librerias/jquery/jquery-3.3.1.js

Summary

Maintainability
F
4 mos
Test Coverage

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

/*!
 * jQuery JavaScript Library v3.3.1
 * https://jquery.com/
 *
 * Includes Sizzle.js
Severity: Major
Found in public_/librerias/jquery/jquery-3.3.1.js - About 2 wks to fix

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

    (function( window ) {

var i,
    support,
    Expr,
    Severity: Major
    Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 day to fix

        Function setDocument has 245 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 public_/librerias/jquery/jquery-3.3.1.js - About 1 day to fix

          Function Deferred has 178 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 public_/librerias/jquery/jquery-3.3.1.js - About 7 hrs to fix

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

            function defaultPrefilter( elem, props, opts ) {
    var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
        isBox = "width" in props || "height" in props,
        anim = this,
        orig = {},
            Severity: Major
            Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 4 hrs to fix

                  Function Animation has 96 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 public_/librerias/jquery/jquery-3.3.1.js - About 3 hrs to fix

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

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

        var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
            eventPath = [ elem || document ],
            type = hasOwn.call( event, "type" ) ? event.type : event,
                    Severity: Major
                    Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 3 hrs to fix

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

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

                xhr.open(
                          Severity: Major
                          Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 2 hrs to fix

                                                      Function addCombinator has 46 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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

                                                            Function select has 46 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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

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

        if ( !arguments.length ) {
                                                              Severity: Minor
                                                              Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

                                                                      Function style has 41 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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

                                                                        Function access has 41 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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

                                                                              toggleClass: function( value, stateVal ) {
        var type = typeof value,
            isValidValue = type === "string" || Array.isArray( value );

        if ( typeof stateVal === "boolean" && isValidValue ) {
                                                                          Severity: Minor
                                                                          Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

                                                                              function adjustCSS( elem, prop, valueParts, tween ) {
    var adjusted, scale,
        maxIterations = 20,
        currentValue = tween ?
            function() {
                                                                              Severity: Minor
                                                                              Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

                                                                                    function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
    var i = dimension === "width" ? 1 : 0,
        extra = 0,
        delta = 0;
                                                                                    Severity: Minor
                                                                                    Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

                                                                                            handlers: function( event, handlers ) {
        var i, handleObj, sel, matchedHandlers, matchedSelectors,
            handlerQueue = [],
            delegateCount = handlers.delegateCount,
            cur = event.target;
                                                                                        Severity: Minor
                                                                                        Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

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

        if ( isFunction( value ) ) {
                                                                                                Severity: Minor
                                                                                                Found in public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

                                                                                                  Function speed has 30 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 ||
            isFunction( speed ) && speed,
        duration: speed,
                                                                                                  Severity: Minor
                                                                                                  Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

                                                                                                      function getWidthOrHeight( elem, dimension, extra ) {

    // Start with computed style
    var styles = getStyles( elem ),
        val = curCSS( elem, dimension, styles ),
                                                                                                      Severity: Minor
                                                                                                      Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

                                                                                                                      position: function() {
        if ( !this[ 0 ] ) {
            return;
        }
                                                                                                                  Severity: Minor
                                                                                                                  Found in public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

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

        if ( isFunction( value ) ) {
                                                                                                                    Severity: Minor
                                                                                                                    Found in public_/librerias/jquery/jquery-3.3.1.js - About 1 hr to fix

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

                                                                                                                          when: function( singleValue ) {
        var

            // count of uncompleted subordinates
            remaining = arguments.length,
                                                                                                                      Severity: Minor
                                                                                                                      Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 50 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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

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

                                                                                                                                    function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                      Open

                                                                                                                                                      } else if ( copy !== undefined ) {
                    target[ name ] = copy;
                }
                                                                                                                                      Severity: Major
                                                                                                                                      Found in public_/librerias/jquery/jquery-3.3.1.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 ( isFunction( this[ match ] ) ) {
                                this[ match ]( context[ match ] );
                                                                                                                                        Severity: Major
                                                                                                                                        Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                  Open

                                                                                                                                                                      if ( Expr.relative[ tokens[j].type ] ) {
                        break;
                    }
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                      Open

                                                                                                                                                                              if ( matchedSelectors[ sel ] === undefined ) {
                            matchedSelectors[ sel ] = handleObj.needsContext ?
                                jQuery( sel, this ).index( cur ) > -1 :
                                jQuery.find( sel, this, null, [ cur ] ).length;
                        }
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

                                                                                                                                                                                if ( matchedSelectors[ sel ] ) {
                            matchedHandlers.push( handleObj );
                        }
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                            Open

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

                    } else {
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                              Open

                                                                                                                                                                                      if ( node && node.value === id ) {
                            return [ elem ];
                        }
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                  Open

                                                                                                                                                                                          if ( nid === expando ) {
                            context.removeAttribute( "id" );
                        }
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 && ( node.type || "" ).toLowerCase()  !== "module" ) {
                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                    Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 = camelCase( name.slice( 5 ) );
                                dataAttr( elem, name, data[ name ] );
                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js - About 45 mins to fix

                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                            Open

                                                                                                                                                                                                                    if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
                            cur += clazz + " ";
                        }
                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                            Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 40 mins to fix

                                                                                                                                                                                                Consider simplifying this complex logical expression.
                                                                                                                                                                                                Open

                                                                                                                                                                                                        if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
                context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {

            context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
            if ( !context ) {
                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                Found in public_/librerias/jquery/jquery-3.3.1.js - About 40 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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 35 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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 35 mins to fix

                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                        return results;
                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                  return value;
                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                      Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                    return ret;
                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                        Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                    return event.which;
                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                            Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                      return elem[ name ];
                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                              Found in public_/librerias/jquery/jquery-3.3.1.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 public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                  Open

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

                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        return data;
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                              return JSON.parse( data );
                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                      Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                    return 0;
                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                        Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                  return ret == null ? undefined : ret;
                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                return results;
                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                            Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                          return elem.disabled === disabled;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                            return this;
                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                          return this.each( function( i ) {
            var val;

            if ( this.nodeType !== 1 ) {
                return;
                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                  Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                            return compare & 4 ? -1 : 1;
                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                    Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                          return results;
                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                      Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                return false;
                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                        Found in public_/librerias/jquery/jquery-3.3.1.js - About 30 mins to fix

                                                                                                                                                                                                                                                          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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7447..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 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

                                                                                                                                                                                                                                                              preFilter: {
        "ATTR": function( match ) {
            match[1] = match[1].replace( runescape, funescape );

            // Move the given value to match[3] whether quoted or unquoted
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1564..1637

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 603.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                                                                                                                  while ( t-- ) {
            tmp = rtypenamespace.exec( types[ t ] ) || [];
            type = origType = tmp[ 1 ];
            namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4405..4452

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                          tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
    var matched, match, tokens, type,
        soFar, groups, preFilters,
        cached = tokenCache[ selector + " " ];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2025..2090

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 480.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

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

        if ( typeof type !== "string" ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4024..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 468.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function ajaxHandleResponses( s, jqXHR, responses ) {

    var ct, type, finalDataType, firstDataType,
        contents = s.contents,
        dataTypes = s.dataTypes;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8675..8725

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                              for ( ; i < len; i++ ) {
        if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
            matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
        } else {
            matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2313..2342

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 333.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                                                                                                                  return this.each( function( i ) {
            var val;

            if ( this.nodeType !== 1 ) {
                return;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7742..7772

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
            event.currentTarget = matched.elem;

            j = 0;
            while ( ( handleObj = matched.handlers[ j++ ] ) &&
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4627..4651

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

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

            // ( event )  dispatched jQuery.Event
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 3541..3571
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5226..5256

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 252.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                                                                                                              for ( ; i < length; i++ ) {

        // Only deal with non-null/undefined values
        if ( ( options = arguments[ i ] ) != null ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 317..349
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 201..233

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 250.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          getText = Sizzle.getText = function( elem ) {
    var node,
        ret = "",
        i = 0,
        nodeType = elem.nodeType;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1513..1542

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 221.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              dequeue: function( elem, type ) {
        type = type || "fx";

        var queue = jQuery.queue( elem, type ),
            startLength = queue.length,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 1868..1901
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 3977..4010

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "lang": markFunction( function( lang ) {
            // lang value must be a valid identifier
            if ( !ridentifier.test(lang || "") ) {
                Sizzle.error( "unsupported lang: " + lang );
            }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1860..1879

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8628..8650

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 208.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
    var i,
        setMatchers = [],
        elementMatchers = [],
        cached = compilerCache[ selector + " " ];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2446..2474

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 200.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              contains = hasCompare || rnative.test( docElem.contains ) ?
        function( a, b ) {
            var adown = a.nodeType === 9 ? a.documentElement : a,
                bup = b && b.parentNode;
            return a === bup || !!( bup && bup.nodeType === 1 && (
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1286..1305

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 196.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  jQuery.event.special[ fix ] = {
            setup: function() {
                var doc = this.ownerDocument || this,
                    attaches = dataPriv.access( doc, fix );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5143..5164

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 196.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          jQuery.each( {
    mouseenter: "mouseover",
    mouseleave: "mouseout",
    pointerenter: "pointerover",
    pointerleave: "pointerout"
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5000..5026

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 195.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9228..9267

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                      if ( bySet && i !== matchedCount ) {
                j = 0;
                while ( (matcher = setMatchers[j++]) ) {
                    matcher( unmatched, setMatched, context, xml );
                }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2401..2430

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                          try {
    push.apply(
        (arr = slice.call( preferredDoc.childNodes )),
        preferredDoc.childNodes
    );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 745..771

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 193.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  while ( i-- ) {
            token = tokens[i];

            // Abort if we hit a combinator
            if ( Expr.relative[ (type = token.type) ] ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2515..2540

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 192.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          Sizzle.uniqueSort = function( results ) {
    var elem,
        duplicates = [],
        j = 0,
        i = 0;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1480..1507

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                          Sizzle.attr = function( elem, name ) {
    // Set document vars if needed
    if ( ( elem.ownerDocument || elem ) !== document ) {
        setDocument( elem );
    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1451..1470

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 180.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              css: function( name, value ) {
        return access( this, function( elem, name, value ) {
            var styles, len,
                map = {},
                i = 0;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6848..6869

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8774..8798

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  return this.map( function() {

            // Can add propHook for "elements" to filter or add form elements
            var elements = jQuery.prop( this, "elements" );
            return elements ? jQuery.makeArray( elements ) : this;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9509..9531

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                              jQuery.cssHooks[ prefix + suffix ] = {
        expand: function( value ) {
            var i = 0,
                expanded = {},
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6825..6840

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 138.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

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

        if ( elem ) {
            type = ( type || "fx" ) + "queue";
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 5 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 1849..1866
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 3958..3975

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 136.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createPositionalPseudo( fn ) {
    return markFunction(function( argument ) {
        argument = +argument;
        return markFunction(function( seed, matches ) {
            var j,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1001..1017

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 136.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {

            bubbleType = special.delegateType || type;
            if ( !rfocusMorph.test( bubbleType + type ) ) {
                cur = cur.parentNode;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4522..4537

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 136.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          if ( !support.attributes || !assert(function( el ) {
    el.innerHTML = "<input/>";
    el.firstChild.setAttribute( "value", "" );
    return el.firstChild.getAttribute( "value" ) === "";
}) ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2590..2600

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 132.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

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

    // Remember the old values, and insert the new ones
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6392..6410

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                      for ( ; i < l; i++ ) {
                for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {

                    // Always skip document fragments
                    if ( cur.nodeType < 11 && ( targets ?
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2919..2933

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 130.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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.matchesSelector = rnative.test( (matches = docElem.matches ||
        docElem.webkitMatchesSelector ||
        docElem.mozMatchesSelector ||
        docElem.oMatchesSelector ||
        docElem.msMatchesSelector) )) ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1258..1274

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 129.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function condense( unmatched, map, filter, context, xml ) {
    var elem,
        newUnmatched = [],
        i = 0,
        len = unmatched.length,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 4812..4831
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2178..2197

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 128.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function ajaxExtend( target, src ) {
    var key, deep,
        flatOptions = jQuery.ajaxSettings.flatOptions || {};

    for ( key in src ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8655..8669

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 123.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          if ( !assert(function( el ) {
    return el.getAttribute("disabled") == null;
}) ) {
    addHandle( booleans, function( elem, name, isXML ) {
        var val;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2604..2616

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                              for ( ; ( node = nodes[ i ] ) != null; i++ ) {
        if ( !keepData && node.nodeType === 1 ) {
            jQuery.cleanData( getAll( node ) );
        }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5767..5779

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          jQuery.each( {
    slideDown: genFx( "show" ),
    slideUp: genFx( "hide" ),
    slideToggle: genFx( "toggle" ),
    fadeIn: { opacity: "show" },
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 9120..9131
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7577..7588

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {

            // Remember the original values
            width = style.width;
            minWidth = style.minWidth;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6140..6155

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 118.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                                                                                                              grep: function( elems, callback, invert ) {
        var callbackInverse,
            matches = [],
            i = 0,
            length = elems.length,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 472..489

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
                context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {

            context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
            if ( !context ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2497..2511

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 113.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          jQuery.each( [ "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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7567..7574

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                      var elem, j, matcher,
                matchedCount = 0,
                i = "0",
                unmatched = seed && [],
                setMatched = [],
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2351..2361

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                          Similar 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 10187..10199

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                          if ( !assert(function( el ) {
    el.innerHTML = "<a href='#'></a>";
    return el.firstChild.getAttribute("href") === "#" ;
}) ) {
    addHandle( "type|href|height|width", function( elem, name, isXML ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2577..2586

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 110.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                                  if ( simple ) {
                            while ( dir ) {
                                node = elem;
                                while ( (node = node[ dir ]) ) {
                                    if ( ofType ?
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1706..1718

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                          Similar 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 15..38

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 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

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

                                                                                                                                                                                                                                                              if ( data == null && fn == null ) {

        // ( types, fn )
        fn = selector;
        data = selector = undefined;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 3502..3517
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5187..5202

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 107.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                                                                                                              toggle: function( state ) {
        if ( typeof state === "boolean" ) {
            return state ? this.show() : this.hide();
        }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6876..6888

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                              funescape = function( _, escaped, escapedWhitespace ) {
        var high = "0x" + escaped - 0x10000;
        // NaN means non-codepoint
        // Support: Firefox<24
        // Workaround erroneous numeric interpretation of +"0x"
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 730..742

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                          Similar blocks of code found in 3 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 public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 7938..7943
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9128..9133

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                                  } else if ( (oldCache = uniqueCache[ key ]) &&
                            oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {

                            // Assign to newCache so results back-propagate to previous elements
                            return (newCache[ 2 ] = oldCache[ 2 ]);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2135..2148

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 101.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9849..9853

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                          function assert( fn ) {
    var el = document.createElement("fieldset");

    try {
        return !!fn( el );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 915..930

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                          if ( elem.nodeType === 9 ) {
                    doc = elem.documentElement;

                    // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
                    // whichever is greatest
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 9431..9441
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 10221..10231

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                      handleObj = jQuery.extend( {
                type: type,
                origType: origType,
                data: data,
                handler: handler,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4339..4348

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              makeArray: function( arr, results ) {
        var ret = results || [];

        if ( arr != null ) {
            if ( isArrayLike( Object( arr ) ) ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 411..426

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              if ( one === 1 ) {
        origFn = fn;
        fn = function( event ) {

            // Can use an empty set, since event contains the info
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 3524..3533
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5209..5218

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 96.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createCache() {
    var keys = [];

    function cache( key, value ) {
        // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 888..900

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 95.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          jQuery.each( ( "blur focus focusin focusout 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8435..8445

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 94.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Similar blocks of code found in 3 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 public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 9001..9007
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6978..6984

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                          if ( (m = match[1]) ) {

                    // Document context
                    if ( nodeType === 9 ) {
                        if ( (elem = context.getElementById( m )) ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 798..831

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 92.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          jQuery.fn.extend( {
    attr: function( name, value ) {
        return access( this, jQuery.attr, name, value, arguments.length > 1 );
    },
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7893..7903

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "TAG": function( nodeNameSelector ) {
            var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
            return nodeNameSelector === "*" ?
                function() { return true; } :
                function( elem ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1641..1648

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 87.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 {

            // For "content", subtract padding
            if ( box === "content" ) {
                delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.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 87.

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

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

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 selector !== "string" ) {
            return this.pushStack( jQuery( selector ).filter( function() {
                for ( i = 0; i < len; i++ ) {
                    if ( jQuery.contains( self[ i ], this ) ) {
                        return true;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2693..2701

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                          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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9113..9120

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "text": function( elem ) {
            var attr;
            return elem.nodeName.toLowerCase() === "input" &&
                elem.type === "text" &&
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1953..1961

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          function elementMatcher( matchers ) {
    return matchers.length > 1 ?
        function( elem, context, xml ) {
            var i = matchers.length;
            while ( i-- ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 4798..4810
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2155..2167

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 83.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if ( support.matchesSelector && documentIsHTML &&
        !compilerCache[ expr + " " ] &&
        ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
        ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1423..1438

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 83.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          jQuery.noConflict = function( deep ) {
    if ( window.$ === jQuery ) {
        window.$ = _$;
    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 10284..10294

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 ( bulk ) {

            // Bulk operations run against the entire set
            if ( raw ) {
                fn.call( elems, value );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4125..4138

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              eq: function( i ) {
        var len = this.length,
            j = +i + ( i < 0 ? len : 0 );
        return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
    },
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 157..161

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 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

                                                                                                                                                                                                                                                                      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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7325..7330

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          jQuery.ajaxSetup( {
    jsonp: "callback",
    jsonpCallback: function() {
        var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
        this[ callback ] = true;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 8167..8174
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9822..9829

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              clone: function( dataAndEvents, deepDataAndEvents ) {
        dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
        deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

        return this.map( function() {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 5858..5865
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5809..5816

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 75.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  return domManip( this, arguments, function( elem ) {
            if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
                var target = manipulationTarget( this, elem );
                target.insertBefore( elem, target.firstChild );
            }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5738..5743

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              support.getById = assert(function( el ) {
        docElem.appendChild( el ).id = expando;
        return !document.getElementsByName || !document.getElementsByName( expando ).length;
    });
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1117..1120

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "focus": function( elem ) {
            return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
        },
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1891..1893

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  "checked": function( elem ) {
            // In CSS3, :checked should return both checked and selected elements
            // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
            var nodeName = elem.nodeName.toLowerCase();
            return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 4438..4443
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1904..1909

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  return domManip( this, arguments, function( elem ) {
            if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
                var target = manipulationTarget( this, elem );
                target.appendChild( elem );
            }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5729..5734

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                          isXML = Sizzle.isXML = function( elem ) {
    // documentElement is verified for cases where it doesn't yet exist
    // (such as loading iframes in IE - #4833)
    var documentElement = elem && (elem.ownerDocument || elem).documentElement;
    return documentElement ? documentElement.nodeName !== "HTML" : false;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1036..1041

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 68.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createButtonPseudo( type ) {
    return function( elem ) {
        var name = elem.nodeName.toLowerCase();
        return (name === "input" || name === "button") && elem.type === type;
    };
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 990..995

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 67.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  if ( scripts ) {
            j = 0;
            while ( ( elem = tmp[ j++ ] ) ) {
                if ( rscriptType.test( elem.type || "" ) ) {
                    scripts.push( elem );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5651..5658

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "empty": function( elem ) {
            // http://www.w3.org/TR/selectors/#empty-pseudo
            // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
            //   but not by others (comment: 8; processing instruction: 7; etc.)
            // nodeType < 6 works because attributes (2) do not appear as children
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1922..1933

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 66.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function addHandle( attrs, handler ) {
    var arr = attrs.split("|"),
        i = arr.length;

    while ( i-- ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 937..944

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 66.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                      if ( special.add ) {
                special.add.call( elem, handleObj );

                if ( !handleObj.handler.guid ) {
                    handleObj.handler.guid = handler.guid;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 2731..2737
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4367..4373

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 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 public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 7870..7872
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9060..9062

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
            var i = argument < 0 ? argument + length : argument;
            for ( ; ++i < length; ) {
                matchIndexes.push( i );
            }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2000..2006

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
            var i = argument < 0 ? argument + length : argument;
            for ( ; --i >= 0; ) {
                matchIndexes.push( i );
            }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1992..1998

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  return {
            top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
            left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
        };
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 10138..10141

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              is: function( selector ) {
        return !!winnow(
            this,

            // If this is a positional/relative selector, check membership in the returned set
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2718..2729

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 64.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  if ( fn ) {
            for ( ; i < len; i++ ) {
                fn(
                    elems[ i ], key, raw ?
                    value :
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4140..4144

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 64.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function toSelector( tokens ) {
    var i = 0,
        len = tokens.length,
        selector = "";
    for ( ; i < len; i++ ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2092..2100

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  beforeunload: {
            postDispatch: function( event ) {

                // Support: Firefox 20+
                // Firefox doesn't alert if the returnValue field is not set.
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4851..4860

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 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 public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 9221..9225
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9999..10003

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                          while ( ( className = classNames[ i++ ] ) ) {

                    // Check each className given, space separated list
                    if ( self.hasClass( className ) ) {
                        self.removeClass( className );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8390..8397

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              support.getElementsByTagName = assert(function( el ) {
        el.appendChild( document.createComment("") );
        return !el.getElementsByTagName("*").length;
    });
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1096..1099

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 62.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              cssHooks: {
        opacity: {
            get: function( elem, computed ) {
                if ( computed ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 6673..6684
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6599..6609

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  Expr.filter["ID"] = function( id ) {
            var attrId = id.replace( runescape, funescape );
            return function( elem ) {
                return elem.getAttribute("id") === attrId;
            };
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1132..1137

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9333..9337

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              relative: {
        ">": { dir: "parentNode", first: true },
        " ": { dir: "parentNode" },
        "+": { dir: "previousSibling", first: true },
        "~": { dir: "previousSibling" }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 4150..4155
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1557..1562

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                  var j, origCount, tmp,
            events, t, handleObj,
            special, handlers, type, namespaces, origType,
            elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 2759..2761
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4392..4396

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  "target": function( elem ) {
            var hash = window.location && window.location.hash;
            return hash && hash.slice( 1 ) === elem.id;
        },
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1882..1885

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 59.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createInputPseudo( type ) {
    return function( elem ) {
        var name = elem.nodeName.toLowerCase();
        return name === "input" && elem.type === type;
    };
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 979..984

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                      if ( match && ( match[ 1 ] || !context ) ) {

                // HANDLE: $(html) -> $(array)
                if ( match[ 1 ] ) {
                    context = context instanceof jQuery ? context[ 0 ] : context;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 123..169
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2766..2827

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                      if ( tag === "*" ) {
                while ( (elem = results[i++]) ) {
                    if ( elem.nodeType === 1 ) {
                        tmp.push( elem );
                    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1166..1174

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
            jqXHR.setRequestHeader( "Content-Type", s.contentType );
        }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 7922..7924
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9123..9125

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
        // Operator (capture 2)
        "*([*^$|!~]?=)" + whitespace +
        // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
        "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 673..678

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              stopPropagation: function() {
        var e = this.originalEvent;

        this.isPropagationStopped = returnTrue;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 5416..5424

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              preventDefault: function() {
        var e = this.originalEvent;

        this.isDefaultPrevented = returnTrue;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 5425..5433

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              var i, tokens, token, type, find,
        compiled = typeof selector === "function" && selector,
        match = !seed && tokenize( (selector = compiled.selector || selector) );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2486..2488

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 59.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function multipleContexts( selector, contexts, results ) {
    var i = 0,
        len = contexts.length;
    for ( ; i < len; i++ ) {
        Sizzle( selector, contexts[i], results );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 5102..5109
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2169..2176

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  if ( !elem ) {
            return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
        }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2943..2945

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                              while ( ( clazz = classes[ j++ ] ) ) {
                        if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
                            cur += clazz + " ";
                        }
                    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8308..8312

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 57.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  if ( value !== undefined ) {
            type = typeof value;

            // Convert "+=" or "-=" to relative numbers (#7345)
            if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 6724..6761
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6653..6697

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 57.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  if ( isFunction( value ) ) {
            return this.each( function( j ) {
                jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
            } );
        }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 7846..7850

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 57.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  if ( isFunction( value ) ) {
            return this.each( function( j ) {
                jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
            } );
        }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 7809..7813

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 57.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  "button": function( elem ) {
            var name = elem.nodeName.toLowerCase();
            return name === "input" && elem.type === "button" || name === "button";
        },
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 4499..4502
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1948..1951

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                      for ( ; i < length; i++ ) {
                value = callback( elems[ i ], i, arg );

                if ( value != null ) {
                    ret.push( value );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 501..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 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

                                                                                                                                                                                                                                                          for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
    Expr.pseudos[ i ] = createInputPseudo( i );
}
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2013..2015

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 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

                                                                                                                                                                                                                                                                  blur: {
            trigger: function() {
                if ( this === safeActiveElement() && this.blur ) {
                    this.blur();
                    return false;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4827..4835

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  return i ?
            // Do a sibling check if the nodes have a common ancestor
            siblingCheck( ap[i], bp[i] ) :

            // Otherwise nodes in our document sort first
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1397..1404

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

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

                // Handle the global AJAX counter
                if ( !( --jQuery.active ) ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 7820..7826
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9292..9298

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 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 public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 3592..3595
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8462..8465

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              var options, name, src, copy, copyIsArray, clone,
        target = arguments[ 0 ] || {},
        i = 1,
        length = arguments.length,
        deep = false;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 292..296
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 175..179

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                          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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 566..568

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                          if ( bySet ) {
                    // They will have gone through all possible matchers
                    if ( (elem = !matcher && elem) ) {
                        matchedCount--;
                    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 5015..5025
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2386..2396

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  s.converters[ "script json" ] = function() {
            if ( !responseContainer ) {
                jQuery.error( callbackName + " was not called" );
            }
            return responseContainer[ 0 ];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 8207..8212
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9856..9861

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  "even": createPositionalPseudo(function( matchIndexes, length ) {
            var i = 0;
            for ( ; i < length; i += 2 ) {
                matchIndexes.push( i );
            }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 3 other locations - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1976..1982
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1984..1990
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 2090..2096

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  "odd": createPositionalPseudo(function( matchIndexes, length ) {
            var i = 1;
            for ( ; i < length; i += 2 ) {
                matchIndexes.push( i );
            }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 3 other locations - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1976..1982
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1984..1990
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 2082..2088

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                      if ( xml ) {
                while ( (elem = elem[ dir ]) ) {
                    if ( elem.nodeType === 1 || checkNonElements ) {
                        if ( matcher( elem, context, xml ) ) {
                            return true;
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2123..2151

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          Sizzle.contains = function( context, elem ) {
    // Set document vars if needed
    if ( ( context.ownerDocument || context ) !== document ) {
        setDocument( context );
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1443..1449

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
            position = jQuery.css( elem, "position" ),
            curElem = jQuery( elem ),
            props = {};
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 10024..10027

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                              if ( ( option.selected || i === index ) &&

                            // Don't return options that are disabled or in a disabled optgroup
                            !option.disabled &&
                            ( !option.parentNode.disabled ||
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 2236..2251
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7805..7820

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                          abort: function( statusText ) {
                    var finalText = statusText || strAbort;
                    if ( transport ) {
                        transport.abort( finalText );
                    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9022..9029

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                              jQuery.merge( this, jQuery.parseHTML(
                        match[ 1 ],
                        context && context.nodeType ? context.ownerDocument || context : document,
                        true
                    ) );
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2774..2778

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                          if ( dataType[ 0 ] === "+" ) {
                    dataType = dataType.slice( 1 ) || "*";
                    ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );

                // Otherwise append
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8614..8621

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                          support.sortDetached = assert(function( el ) {
    // Should return 1, but returns 4 (following)
    return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
});
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2569..2572

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 53.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if ( dataTypes[ 1 ] ) {
        for ( conv in s.converters ) {
            converters[ conv.toLowerCase() ] = s.converters[ conv ];
        }
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8737..8741

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

            // Building a settings object
            ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8900..8908

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 ( isArrayLike( elems ) ) {
            length = elems.length;
            for ( ; i < length; i++ ) {
                value = callback( elems[ i ], i, arg );
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 500..518

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                      deferred[ tuple[ 0 ] ] = function() {
                deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
                return this;
            };
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 3320..3323

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                      var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
                extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 9417..9418
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 10207..10208

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                              add: function( selector, context ) {
        return this.pushStack(
            jQuery.uniqueSort(
                jQuery.merge( this.get(), jQuery( selector, context ) )
            )
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2958..2964

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              map: function( callback ) {
        return this.pushStack( jQuery.map( this, function( elem, i ) {
            return callback.call( elem, i, elem );
        } ) );
    },
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 271..275
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 139..143

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 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

                                                                                                                                                                                                                                                          if ( typeof define === "function" && define.amd ) {
    define( "jquery", [], function() {
        return jQuery;
    } );
}
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 10268..10272

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                                      while ( (node = ++nodeIndex && node && node[ dir ] ||

                                // Fallback to seeking `elem` from the start
                                (diff = nodeIndex = 0) || start.pop()) ) {
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1731..1741

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                                          if ( returned && isFunction( returned.promise ) ) {
                                    returned.promise()
                                        .progress( newDefer.notify )
                                        .done( newDefer.resolve )
                                        .fail( newDefer.reject );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 45 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 1130..1137
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 3277..3284

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  var handleObjIn, eventHandle, tmp,
            events, t, handleObj,
            special, handlers, type, namespaces, origType,
            elemData = dataPriv.get( elem );
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4278..4281

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                      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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9979..9986

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 49.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          jQuery.each( [
    "tabIndex",
    "readOnly",
    "maxLength",
    "cellSpacing",
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8257..8270

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 ( handle && handle.apply && acceptData( cur ) ) {
                event.result = handle.apply( cur, data );
                if ( event.result === false ) {
                    event.preventDefault();
                }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4555..4560

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              if ( typeof target === "boolean" ) {
        deep = target;

        // Skip the boolean and the target
        target = arguments[ i ] || {};
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 182..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 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
            return;
        }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 6708..6710
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 6637..6639

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              addBack: function( selector ) {
        return this.add( selector == null ?
            this.prevObject : this.prevObject.filter( selector )
        );
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 5493..5497
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2966..2970

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              triggerHandler: function( type, data ) {
        var elem = this[ 0 ];
        if ( elem ) {
            return jQuery.event.trigger( type, data, elem, true );
        }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5263..5268

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                      var simple = type.slice( 0, 3 ) !== "nth",
                forward = type.slice( -4 ) !== "last",
                ofType = what === "of-type";
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1685..1687

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                      for ( i = 0, l = srcElements.length; i < l; i++ ) {
                fixInput( srcElements[ i ], destElements[ i ] );
            }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 5823..5825

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                                          for ( i = 0, l = srcElements.length; i < l; i++ ) {
                    cloneCopyEvent( srcElements[ i ], destElements[ i ] );
                }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-3.3.1.js on lines 5812..5814

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  "selected": function( elem ) {
            // Accessing this property makes selected-by-default
            // options in Safari work properly
            if ( elem.parentNode ) {
                elem.parentNode.selectedIndex;
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 4445..4453
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1911..1919

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                      if ( isSuccess ) {
                deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
            } else {
                deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
            }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 7802..7806
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9274..9278

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              jQuery.fx.timer(
        jQuery.extend( tick, {
            elem: elem,
            anim: animation,
            queue: animation.opts.queue
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7371..7377

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                          if ( options.xhrFields ) {
                    for ( i in options.xhrFields ) {
                        xhr[ i ] = options.xhrFields[ i ];
                    }
                }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 8404..8408
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9595..9599

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
            a.compareDocumentPosition( b ) :

            // Otherwise we know they are disconnected
            1;
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1327..1331

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              proxy = function() {
        return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
    };
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 546..548

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 7146..7148
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 9428..9430

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                      if ( el.querySelectorAll("[msallowcapture^='']").length ) {
                rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
            }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 1215..1217

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                        if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5947..5958

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                                  this.isDefaultPrevented = src.defaultPrevented ||
                src.defaultPrevented === undefined &&

                // Support: Android <=2.3 only
                src.returnValue === false ?
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4921..4926

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 46.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                      if ( selector ) {
                handlers.splice( handlers.delegateCount++, 0, handleObj );
            } else {
                handlers.push( handleObj );
            }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 30 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 2740..2744
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 4376..4380

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

                                                                                                                                                                                                                                                              trigger: function( type, data ) {
        return this.each( function() {
            jQuery.event.trigger( type, data, this );
        } );
    },
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 2 other locations - About 30 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/flot/jquery.js on lines 3597..3601
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 5258..5262

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 8872..8885

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                              return type === "array" || length === 0 ||
        typeof length === "number" && length > 0 && ( length - 1 ) in obj;
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 582..583

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                                                                                                          support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 2558..2558

                                                                                                                                                                                                                                                          Duplicated Code

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

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

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

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

            // We're done with this property
            return tween;
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in public_/librerias/jquery/jquery-3.3.1.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          public_/librerias/jquery/jquery-1.11.1.js on lines 7094..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 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