pinclub/pinclub

File jquery-2.1.0.js has 6124 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*!
 * jQuery JavaScript Library v2.1.0
 * http://jquery.com/
 *
 * Includes Sizzle.js

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

Open

    (function (window) {

      var i,
        support,
        Expr,

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

Open

    ajax: function (url, options) {

      // If url is an object, simulate pre-1.5 signature
      if (typeof url === "object") {
        options = url;

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

Open

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

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

Open

  jQuery.Callbacks = function (options) {

    // Convert options from String-formatted to Object-formatted if needed
    // (we check in cache first)
    options = typeof options === "string" ?

Consider simplifying this complex logical expression.

Open

        if (event.pageX == null && original.clientX != null) {
          eventDoc = event.target.ownerDocument || document;
          doc = eventDoc.documentElement;
          body = eventDoc.body;

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

Open

  function defaultPrefilter(elem, props, opts) {
    /* jshint validthis: true */
    var prop, value, toggle, tween, hooks, oldfire, display,
      anim = this,
      orig = {},

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

Open

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

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

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

Open

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

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

Open

      function Sizzle(selector, context, results, seed) {
        var match, elem, m, nodeType,
        // QSA vars
          i, groups, old, nid, newContext, newSelector;

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

Open

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

      var handleObjIn, eventHandle, tmp,
        events, t, handleObj,
        special, handlers, type, namespaces, origType,

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

Open

      function matcherFromGroupMatchers(elementMatchers, setMatchers) {
        var bySet = setMatchers.length > 0,
          byElement = elementMatchers.length > 0,
          superMatcher = function (seed, context, xml, results, outermost) {
            var elem, j, matcher,

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

Open

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

        // Called once

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

Open

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

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

Open

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

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

Open

    Deferred: function (func) {
      var tuples = [
          // action, add listener, listener list, final state
          [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
          [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],

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

Open

          "CHILD": function (type, what, argument, first, last) {
            var simple = type.slice(0, 3) !== "nth",
              forward = type.slice(-4) !== "last",
              ofType = what === "of-type";

Consider simplifying this complex logical expression.

Open

                  if (forward && useCache) {
                    // Seek `elem` from a previously-cached index
                    outerCache = parent[ expando ] || (parent[ expando ] = {});
                    cache = outerCache[ type ] || [];
                    nodeIndex = cache[0] === dirruns && cache[1];

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

Open

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

      // HANDLE: $(""), $(null), $(undefined), $(false)
      if (!selector) {

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

Open

    domManip: function (args, callback) {

      // Flatten any nested arrays
      args = concat.apply([], args);

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

Open

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

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

Open

    data: function (key, value) {
      var i, name, data,
        elem = this[ 0 ],
        attrs = elem && elem.attributes;

Consider simplifying this complex logical expression.

Open

          if (( mappedTypes || origType === handleObj.origType ) &&
            ( !handler || handler.guid === handleObj.guid ) &&
            ( !tmp || tmp.test(handleObj.namespace) ) &&
            ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector )) {
            handlers.splice(j, 1);

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

Open

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

      var j, origCount, tmp,
        events, t, handleObj,
        special, handlers, type, namespaces, origType,

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

Open

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

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

Open

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

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

Open

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

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

Open

      function select(selector, context, results, seed) {
        var i, tokens, token, type, find,
          match = tokenize(selector);

        if (!seed) {

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

Open

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

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

Open

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

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

Open

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

      // Types can be a map of types/handlers
      if (typeof types === "object") {

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

Open

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

      if (!arguments.length) {

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

Open

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

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

Open

      function addCombinator(matcher, combinator, base) {
        var dir = combinator.dir,
          checkNonElements = base && dir === "parentNode",
          doneName = done++;

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

Open

    each: function (obj, callback, args) {
      var value,
        i = 0,
        length = obj.length,
        isArray = isArraylike(obj);

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

Open

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

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

Open

  function ajaxHandleResponses(s, jqXHR, responses) {

    var ct, type, finalDataType, firstDataType,
      contents = s.contents,
      dataTypes = s.dataTypes;

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

Open

    when: function (subordinate /* , ..., subordinateN */) {
      var i = 0,
        resolveValues = slice.call(arguments),
        length = resolveValues.length,

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

Open

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

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

Open

    dispatch: function (event) {

      // Make a writable jQuery.Event from the native event object
      event = jQuery.event.fix(event);

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

Open

    setOffset: function (elem, options, i) {
      var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
        position = jQuery.css(elem, "position"),
        curElem = jQuery(elem),
        props = {};

Consider simplifying this complex logical expression.

Open

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

                    // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
                  } else {

Consider simplifying this complex logical expression.

Open

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

          // Make sure we update the tween properties later on

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

Open

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

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

Open

    removeClass: function (value) {
      var classes, elem, cur, clazz, j, finalValue,
        proceed = arguments.length === 0 || typeof value === "string" && value,
        i = 0,
        len = this.length;

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

Open

  jQuery.fn.load = function (url, params, callback) {
    if (typeof url !== "string" && _load) {
      return _load.apply(this, arguments);
    }

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

Open

    addClass: function (value) {
      var classes, elem, cur, clazz, j, finalValue,
        proceed = typeof value === "string" && value,
        i = 0,
        len = this.length;

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

Open

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

      // don't get/set attributes on text, comment and attribute nodes

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

Open

    handlers: function (event, handlers) {
      var i, matches, sel, handleObj,
        handlerQueue = [],
        delegateCount = handlers.delegateCount,
        cur = event.target;

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

Open

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

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

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

Open

    finish: function (type) {
      if (type !== false) {
        type = type || "fx";
      }
      return this.each(function () {

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

Open

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

    // camelCase, specialEasing and expand cssHook pass
    for (index in props) {

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

Open

    fix: function (event) {
      if (event[ jQuery.expando ]) {
        return event;
      }

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

Open

    off: function (types, selector, fn) {
      var handleObj, type;
      if (types && types.preventDefault && types.handleObj) {
        // ( event )  dispatched jQuery.Event
        handleObj = types.handleObj;

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

Open

      "*": [ function (prop, value) {
        var tween = this.createTween(prop, value),
          target = tween.cur(),
          parts = rfxnum.exec(value),
          unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),

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

Open

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

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

Open

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

Consider simplifying this complex logical expression.

Open

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

              context = ( Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [] )[0];

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

Open

  var access = jQuery.access = function (elems, fn, key, value, chainable, emptyGet, raw) {

Avoid deeply nested control flow statements.

Open

              if (matches[ sel ] === undefined) {
                matches[ sel ] = handleObj.needsContext ?
                  jQuery(sel, this).index(cur) >= 0 :
                  jQuery.find(sel, this, null, [ cur ]).length;
              }

Avoid deeply nested control flow statements.

Open

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

Avoid deeply nested control flow statements.

Open

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

            } else {

Avoid deeply nested control flow statements.

Open

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

Avoid deeply nested control flow statements.

Open

            for (conv2 in converters) {

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

Avoid deeply nested control flow statements.

Open

              if (name.indexOf("data-") === 0) {
                name = jQuery.camelCase(name.slice(5));
                dataAttr(elem, name, data[ name ]);
              }

Avoid deeply nested control flow statements.

Open

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

Avoid deeply nested control flow statements.

Open

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

Avoid deeply nested control flow statements.

Open

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

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

Open

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

Avoid deeply nested control flow statements.

Open

                      if (( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff) {
                        // Cache the index of each encountered element
                        if (useCache) {
                          (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
                        }

Avoid deeply nested control flow statements.

Open

              for (match in context) {
                // Properties of context are called as methods if possible
                if (jQuery.isFunction(this[ match ])) {
                  this[ match ](context[ match ]);

Avoid deeply nested control flow statements.

Open

              for (j = 0; (type = events[j]) !== undefined; j++) {
                if (special[ type ]) {
                  jQuery.event.remove(elem, type);

                  // This is a shortcut to avoid jQuery.event.remove's overhead

Avoid deeply nested control flow statements.

Open

            if (conv && s[ "throws" ]) {
              response = conv(response);
            } else {
              try {
                response = conv(response);

Avoid deeply nested control flow statements.

Open

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

Avoid deeply nested control flow statements.

Open

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

Avoid deeply nested control flow statements.

Open

                if (elem && elem.parentNode) {
                  // Handle the case where IE, Opera, and Webkit return items
                  // by name instead of ID
                  if (elem.id === m) {
                    results.push(elem);

Avoid deeply nested control flow statements.

Open

                  if ((elem = matcherOut[i])) {
                    // Restore matcherIn since elem is not yet a final match
                    temp.push((matcherIn[i] = elem));
                  }

Avoid deeply nested control flow statements.

Open

                if ((seed = find(
                  token.matches[0].replace(runescape, funescape),
                    rsibling.test(tokens[0].type) && testContext(context.parentNode) || context
                ))) {

Avoid deeply nested control flow statements.

Open

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

                if (node.src) {
                  // Optional AJAX dependency, but won't run scripts if not present
                  if (jQuery._evalUrl) {

Avoid deeply nested control flow statements.

Open

              if (hasScripts) {
                // Support: QtWebKit
                // jQuery.merge because push.apply(_, arraylike) throws
                jQuery.merge(scripts, getAll(node, "script"));
              }

Avoid deeply nested control flow statements.

Open

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

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

Open

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

Avoid deeply nested control flow statements.

Open

                        if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
                          return false;
                        }

Avoid deeply nested control flow statements.

Open

                if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) &&
                  contains(context, elem) && elem.id === m) {
                  results.push(elem);
                  return results;
                }

Consider simplifying this complex logical expression.

Open

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

          try {

Consider simplifying this complex logical expression.

Open

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

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

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

Open

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

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

Open

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

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

Open

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

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

Open

    on: function (types, selector, data, fn, /*INTERNAL*/ one) {

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

Open

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

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

Open

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

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

Open

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

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

Open

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

Avoid too many return statements within this function.

Open

                return results;

Avoid too many return statements within this function.

Open

        return select(selector.replace(rtrim, "$1"), context, results, seed);

Avoid too many return statements within this function.

Open

              return sortInput ?
                ( indexOf.call(sortInput, a) - indexOf.call(sortInput, b) ) :
                0;

Avoid too many return statements within this function.

Open

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

Avoid too many return statements within this function.

Open

      return jQuery.makeArray(selector, this);

Avoid too many return statements within this function.

Open

              return results;

Avoid too many return statements within this function.

Open

        return this;

Avoid too many return statements within this function.

Open

              return results;

Avoid too many return statements within this function.

Open

        return ret;

Avoid too many return statements within this function.

Open

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

Avoid too many return statements within this function.

Open

                  return results;

Avoid too many return statements within this function.

Open

        return ret == null ?
          undefined :
          ret;

Avoid too many return statements within this function.

Open

            return compare & 4 ? -1 : 1;

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

Open

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

    // Remember the old values, and insert the new ones

• Read up
  Read up

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

Open

          event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );

• Read up
  Read up

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

Open

          event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );

• Read up
  Read up

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

Open

      if (jQuery.isFunction(value)) {
        return this.each(function (j) {
          jQuery(this).removeClass(value.call(this, j, this.className));
        });
      }

• Read up
  Read up

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

Open

      if (jQuery.isFunction(value)) {
        return this.each(function (j) {
          jQuery(this).addClass(value.call(this, j, this.className));
        });
      }

• Read up
  Read up

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

Open

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

      this.isDefaultPrevented = returnTrue;

• Read up
  Read up

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

Open

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

      this.isPropagationStopped = returnTrue;

• Read up
  Read up

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

Open

      if (jQuery.isFunction(html)) {
        return this.each(function (i) {
          jQuery(this).wrapInner(html.call(this, i));
        });
      }

• Read up
  Read up

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

Open

      if (jQuery.isFunction(html)) {
        return this.each(function (i) {
          jQuery(this).wrapAll(html.call(this, i));
        });
      }

• Read up
  Read up

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

Open

          "even": createPositionalPseudo(function (matchIndexes, length) {
            var i = 0;
            for (; i < length; i += 2) {
              matchIndexes.push(i);
            }

• Read up
  Read up

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

Open

          "odd": createPositionalPseudo(function (matchIndexes, length) {
            var i = 1;
            for (; i < length; i += 2) {
              matchIndexes.push(i);
            }

• Read up
  Read up

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

Open

          cur = elem.nodeType === 1 && ( elem.className ?
            ( " " + elem.className + " " ).replace(rclass, " ") :
            ""
            );

• Read up
  Read up

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

Open

          cur = elem.nodeType === 1 && ( elem.className ?
            ( " " + elem.className + " " ).replace(rclass, " ") :
            " "
            );

• Read up
  Read up

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 ]);
        }

• Read up
  Read up

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 ]);
          }

• Read up
  Read up

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);
            } else {

• Read up
  Read up