erikroyall/hilo

View on GitHub
build/hilo.js

Summary

Maintainability
F
3 mos
Test Coverage

File hilo.js has 1932 lines of code (exceeds 250 allowed). Consider refactoring.
Open

// # Hilo

// `0.1.0-pre-dev-beta-10`<br/>

// Built on: 2015-05-06<br/>
Severity: Major
Found in build/hilo.js - About 5 days to fix

    Function class has 105 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        "class": feature.classList === true ? function (action, className) {
          return this.each(function (el) {
            var _i, parts, contains, res = [];
    
            if (typeof className === "string") { // A String
    Severity: Major
    Found in build/hilo.js - About 4 hrs to fix

      Function classify has 71 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      hilo.classify = function () {
          var body = win.Hilo("body")
            , classes = ["js"]
            , _i;
          // Remove the default no-js class
      Severity: Major
      Found in build/hilo.js - About 2 hrs to fix

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

            function str(key, holder) {
        
              // Produce a string from holder[key].
        
              var i,          // The loop counter.
        Severity: Major
        Found in build/hilo.js - About 2 hrs to fix

          Function unitize has 43 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            function unitize (unit, prop) {
          
              /* All the CSS props. that are to be defaulted to px values */
              var pixel = {
                "width": true,
          Severity: Minor
          Found in build/hilo.js - About 1 hr to fix

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

                fade: function (inOut, timing) {
                  if (inOut === "in") {
                    this.show();
                  }
            
            
            Severity: Minor
            Found in build/hilo.js - About 1 hr to fix

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

                    json.parse = function (text, reviver) {
              
                      // The parse method takes a text and an optional reviver function, and returns
                      // a JavaScript value if the text is a valid json text.
              
              
              Severity: Minor
              Found in build/hilo.js - About 1 hr to fix

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

                    fire: (function () {
                      if (document.dispatchEvent) {
                        return function (event) {
                          var evt;
                          
                Severity: Minor
                Found in build/hilo.js - About 1 hr to fix

                  Avoid deeply nested control flow statements.
                  Open

                                    if (contains(parts[_i])) {
                                      el.classList.remove(parts[_i]);
                                    } else {
                                      el.classList.add(parts[_i]);
                                    }
                  Severity: Major
                  Found in build/hilo.js - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                    if (contains(parts[_i])) {
                                      el.classList.remove(parts[_i]);
                                    } else {
                                      el.classList.add(parts[_i]);
                                    }
                    Severity: Major
                    Found in build/hilo.js - About 45 mins to fix

                      Avoid deeply nested control flow statements.
                      Open

                                        if (contains) {
                                          el.className.replace(className, "");
                                        } else {
                                          el.className += " " +  className;
                                        }
                      Severity: Major
                      Found in build/hilo.js - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                          if (contains(parts[_i])) {
                                            el.className.replace(parts[_i], "");
                                          }
                        Severity: Major
                        Found in build/hilo.js - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                            if (!contains(parts[_i])) {
                                              el.className += " " +  parts[_i];
                                            }
                          Severity: Major
                          Found in build/hilo.js - About 45 mins to fix

                            Avoid deeply nested control flow statements.
                            Open

                                            if (v !== undefined) {
                                              value[k] = v;
                                            } else {
                                              delete value[k];
                                            }
                            Severity: Major
                            Found in build/hilo.js - About 45 mins to fix

                              Avoid deeply nested control flow statements.
                              Open

                                                if (contains) {
                                                  el.classList.remove(parts[_i]);
                                                } else {
                                                  el.classList.add(parts[_i]);
                                                }
                              Severity: Major
                              Found in build/hilo.js - About 45 mins to fix

                                Avoid deeply nested control flow statements.
                                Open

                                              if (v) {
                                                partial.push(quote(k) + (gap ? ": " : ":") + v);
                                              }
                                Severity: Major
                                Found in build/hilo.js - About 45 mins to fix

                                  Avoid deeply nested control flow statements.
                                  Open

                                                  if (contains(parts[_i])) {
                                                    el.classList.remove(parts[_i]);
                                                  }
                                  Severity: Major
                                  Found in build/hilo.js - About 45 mins to fix

                                    Avoid deeply nested control flow statements.
                                    Open

                                                    if (contains(parts[_i])) {
                                                      el.className.replace(parts[_i], "");
                                                    } else {
                                                      el.className += " " +  parts[_i];
                                                    }
                                    Severity: Major
                                    Found in build/hilo.js - About 45 mins to fix

                                      Avoid deeply nested control flow statements.
                                      Open

                                                    if (v) {
                                                      partial.push(quote(k) + (gap ? ": " : ":") + v);
                                                    }
                                      Severity: Major
                                      Found in build/hilo.js - About 45 mins to fix

                                        Avoid deeply nested control flow statements.
                                        Open

                                                        if (!contains(parts[_i])) {
                                                          el.classList.add(parts[_i]);
                                                        }
                                        Severity: Major
                                        Found in build/hilo.js - About 45 mins to fix

                                          Avoid deeply nested control flow statements.
                                          Open

                                                            if (contains(parts[_i])) {
                                                              el.className.replace(parts[_i], "");
                                                            } else {
                                                              el.className += " " +  parts[_i];
                                                            }
                                          Severity: Major
                                          Found in build/hilo.js - About 45 mins to fix

                                            Avoid deeply nested control flow statements.
                                            Open

                                                            if (contains(parts[_i])) {
                                                              el.className.replace(parts[_i], "");
                                                            }
                                            Severity: Major
                                            Found in build/hilo.js - About 45 mins to fix

                                              Avoid deeply nested control flow statements.
                                              Open

                                                                if (!contains(parts[_i])) {
                                                                  el.classList.add(parts[_i]);
                                                                }
                                              Severity: Major
                                              Found in build/hilo.js - About 45 mins to fix

                                                Avoid deeply nested control flow statements.
                                                Open

                                                                  if (contains(parts[_i])) {
                                                                    el.classList.remove(parts[_i]);
                                                                  }
                                                Severity: Major
                                                Found in build/hilo.js - About 45 mins to fix

                                                  Avoid deeply nested control flow statements.
                                                  Open

                                                                  if (!contains(parts[_i])) {
                                                                    el.className += " " +  parts[_i];
                                                                  }
                                                  Severity: Major
                                                  Found in build/hilo.js - About 45 mins to fix

                                                    Avoid too many return statements within this function.
                                                    Open

                                                          return new Dom(input);
                                                    Severity: Major
                                                    Found in build/hilo.js - About 30 mins to fix

                                                      Avoid too many return statements within this function.
                                                      Open

                                                            return win.Hilo;
                                                      Severity: Major
                                                      Found in build/hilo.js - About 30 mins to fix

                                                        Avoid too many return statements within this function.
                                                        Open

                                                              return new Dom(input);
                                                        Severity: Major
                                                        Found in build/hilo.js - About 30 mins to fix

                                                          Avoid too many return statements within this function.
                                                          Open

                                                                    return false;
                                                          Severity: Major
                                                          Found in build/hilo.js - About 30 mins to fix

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

                                                              extend(Dom.prototype, {
                                                            
                                                                // ## Helper Functions
                                                            
                                                                // 
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 3 wks to fix
                                                            build/hilo-legacy.js on lines 3963..4879

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 4231.

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

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

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

                                                            See codeclimate-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

                                                              feature = (function () {
                                                                var c = function (tagName) {
                                                                    return doc.createElement(tagName);
                                                                  }
                                                                  , i = c("input")
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 2 wks to fix
                                                            build/hilo-legacy.js on lines 76..509
                                                            src/detect.js on lines 3..436

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 2539.

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

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

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

                                                            See codeclimate-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 () {
                                                            
                                                                if (typeof window.JSON === "object" && typeof window.JSON.parse === "function") {
                                                                  json = window.JSON;
                                                                  
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 1 wk to fix
                                                            build/hilo-legacy.js on lines 749..1071
                                                            src/polyfill.js on lines 17..339

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 1879.

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

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

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

                                                              detected = (function () {
                                                                var engine
                                                                  , browser
                                                                  , system
                                                                  , ua = win.navigator.userAgent
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 1 wk to fix
                                                            build/hilo-legacy.js on lines 513..732

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 1839.

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

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

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

                                                            See codeclimate-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

                                                            hilo.classify = function () {
                                                                var body = win.Hilo("body")
                                                                  , classes = ["js"]
                                                                  , _i;
                                                                // Remove the default no-js class
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 4 days to fix
                                                            build/hilo-legacy.js on lines 5452..5540

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 832.

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

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

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

                                                            See codeclimate-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

                                                              extend(Dom.prototype, {
                                                            
                                                                /**
                                                                 * Sets the display property of sel.els. to "" or given value
                                                                 * 
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 4 days to fix
                                                            build/hilo-legacy.js on lines 5219..5451
                                                            src/fx.js on lines 6..238

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 825.

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

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

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

                                                              hiloAjax = function (config) {
                                                                
                                                                // ```
                                                                // config.
                                                                //  method // HTTP Method (default: "POST")
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 4 days to fix
                                                            build/hilo-legacy.js on lines 3573..3672
                                                            src/ajax.js on lines 25..124

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 741.

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

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

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

                                                            See codeclimate-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

                                                              extend(Dom.prototype, {
                                                            
                                                                // Listen to an event and execute a function when that event happend
                                                            
                                                                /**
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 3 days to fix
                                                            build/hilo-legacy.js on lines 4885..5020
                                                            src/evt.js on lines 6..141

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 618.

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

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

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

                                                              key = {
                                                            
                                                                // Numbers
                                                            
                                                                "0": 48,
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 3 days to fix
                                                            build/hilo-legacy.js on lines 5085..5211
                                                            src/evt.js on lines 206..332

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 527.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              extend(NumberObject.prototype, {
                                                                
                                                                /**
                                                                 * NumberObject.MAX_INTEGER = 9007199254740991
                                                                 * The maximum value of a JavaScript integer
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 2 days to fix
                                                            build/hilo-legacy.js on lines 5565..5739

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 406.

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

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

                                                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 unitize (unit, prop) {
                                                            
                                                                /* All the CSS props. that are to be defaulted to px values */
                                                                var pixel = {
                                                                  "width": true,
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 1 day to fix
                                                            build/hilo-legacy.js on lines 3858..3917
                                                            src/dom.js on lines 91..150

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 274.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              extend(Test.prototype, {
                                                            
                                                                /**
                                                                 * Test if equal
                                                                 *
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 1 day to fix
                                                            build/hilo-legacy.js on lines 3491..3548

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 232.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              hilo = function (input, root, en) {
                                                                if (typeof input === "undefined") {
                                                                  // It's better than not returning anything
                                                                  return win.Hilo;
                                                                } else if (typeof input === "number") {
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 1 day to fix
                                                            build/hilo-legacy.js on lines 3365..3395
                                                            src/core.js on lines 25..55

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 230.

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

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

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

                                                              hilo.create = function (tagName, attrs) {
                                                                var el = new Dom([document.createElement(tagName)]), key;
                                                            
                                                                if (attrs) {
                                                                  /* Add Class if the `className` is set */
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 7 hrs to fix
                                                            build/hilo-legacy.js on lines 3936..3961
                                                            src/dom.js on lines 169..194

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 190.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              var every = function every (o, fun) {
                                                                var t, len, thisp, _i;
                                                            
                                                                if (o === null) {
                                                                  throw new TypeError();
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 6 hrs to fix
                                                            build/hilo-legacy.js on lines 3251..3274
                                                            src/util.js on lines 158..181

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 169.

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

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

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

                                                            See codeclimate-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 each = function each (arr, fn, thisRef) {
                                                                var _i, _l;
                                                            
                                                                // Use Array.prototype.forEach if available
                                                                if (Array.prototype.forEach) {
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 6 hrs to fix
                                                            build/hilo-legacy.js on lines 3185..3206
                                                            src/util.js on lines 92..113

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 162.

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

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

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

                                                            See codeclimate-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 () {
                                                                var evtObj = {}
                                                                  , impEvts;
                                                            
                                                                impEvts = [
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 6 hrs to fix
                                                            build/hilo-legacy.js on lines 5038..5080
                                                            src/evt.js on lines 159..201

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 161.

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

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

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

                                                              var trim = function trim (str) {
                                                                var ws = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" + 
                                                                         "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" + 
                                                                         "\u2029\uFEFF";
                                                            
                                                            
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 5 hrs to fix
                                                            build/hilo-legacy.js on lines 3281..3296
                                                            src/util.js on lines 188..203

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 153.

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

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

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

                                                              var toPrimitive = function toPrimitive (input) {
                                                                var val, valueOf, toString;
                                                            
                                                                if (isPrimitive(input)) {
                                                                  return input;
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 5 hrs to fix
                                                            build/hilo-legacy.js on lines 3136..3163
                                                            src/util.js on lines 43..70

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 152.

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

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

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

                                                            See codeclimate-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 ajaxRequest (method, strOpt, callback, oOpt) {
                                                            
                                                                oOpt = (typeof oOpt === "object" ? oOpt : undefined);
                                                                
                                                                if (typeof strOpt === "string" && typeof callback === "function") {
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 5 hrs to fix
                                                            build/hilo-legacy.js on lines 3687..3702
                                                            src/ajax.js on lines 139..154

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 146.

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

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

                                                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 Dom (els, sel) {
                                                                var _i, _l;
                                                            
                                                                /* Note that `this` is an object and NOT an Array */
                                                            
                                                            
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 5 hrs to fix
                                                            build/hilo-legacy.js on lines 3794..3809
                                                            src/dom.js on lines 27..42

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 135.

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

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

                                                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 hilo             /* Public API */
                                                            
                                                                /* Used to measure performace (Hilo.perf) */
                                                                , start
                                                            
                                                            
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 4 hrs to fix
                                                            build/hilo-legacy.js on lines 37..70

                                                            Duplicated Code

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

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

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

                                                            Tuning

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

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

                                                            (function (A, M, D) {
                                                            
                                                              /* Register Hilo as an AMD module */
                                                            
                                                              /*globals YUI: false, module: false, define: false*/
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 4 hrs to fix
                                                            build/hilo-legacy.js on lines 11..5763

                                                            Duplicated Code

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

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

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

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

                                                              var forIn = function forIn (obj, fn, thisRef) {
                                                                var _i;
                                                            
                                                                // Throw an error if object and function are not provided
                                                                if (!(obj && fn)) {
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 3 hrs to fix
                                                            build/hilo-legacy.js on lines 3210..3228
                                                            src/util.js on lines 117..135

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 99.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              var toInteger = function toInteger (value) {
                                                                var number = +value;
                                                            
                                                                if (Number.isNaN(number)) {
                                                                  return 0;
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 2 hrs to fix
                                                            build/hilo-legacy.js on lines 3110..3122
                                                            src/util.js on lines 17..29

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 93.

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

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

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

                                                            See codeclimate-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 extend = function extend (obj, ext) {
                                                                var _i;
                                                            
                                                                // Throw an error if object and extension are not provided
                                                                if (!(obj && ext)) {
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 2 hrs to fix
                                                            build/hilo-legacy.js on lines 3231..3248
                                                            src/util.js on lines 138..155

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 88.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              hilo.get = function (strOpt, callback, oOpt) {
                                                                ajaxRequest("GET", strOpt, callback, oOpt);
                                                              };
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 2 hrs to fix
                                                            build/hilo-legacy.js on lines 3735..3737
                                                            src/ajax.js on lines 187..189

                                                            Duplicated Code

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

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

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

                                                              hilo.post = function (strOpt, callback, oOpt) {
                                                                ajaxRequest("POST", strOpt, callback, oOpt);
                                                              };
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 2 hrs to fix
                                                            build/hilo-legacy.js on lines 3765..3767

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 82.

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

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

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

                                                              extend(Dom.prototype, {
                                                                ready: function (fn) {
                                                                  this.each(function (el) {
                                                                    el.onreadystatechange = function () {
                                                                      if (el.readyState = "complete") {
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 2 hrs to fix
                                                            build/hilo-legacy.js on lines 5026..5036
                                                            src/evt.js on lines 147..157

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 82.

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

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

                                                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 unhyph (prop) {
                                                                return prop.toLowerCase().replace(/-(.)/g, function (m, m1) {
                                                                  return m1.toUpperCase();
                                                                });
                                                              }
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 2 hrs to fix
                                                            build/hilo-legacy.js on lines 3836..3840
                                                            src/dom.js on lines 69..73

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 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 3 locations. Consider refactoring.
                                                            Open

                                                              var sign = function sign(value) {
                                                                var number = +value;
                                                            
                                                                if (number === 0) {
                                                                  return number;
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 2 hrs to fix
                                                            build/hilo-legacy.js on lines 3165..3177
                                                            src/util.js on lines 72..84

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 77.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              doc.onreadystatechange = function () {
                                                                if (doc.readyState === "complete") {
                                                                  for (_i = 0; _i < callbacks.length; _i += 1) {
                                                                    callbacks[_i]();
                                                                  }
                                                            Severity: Major
                                                            Found in build/hilo.js and 1 other location - About 1 hr to fix
                                                            build/hilo-legacy.js on lines 5750..5756

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 72.

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

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

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

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

                                                            Refactorings

                                                            Further Reading

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

                                                              extend(hilo, {
                                                                each: each,
                                                                extend: extend,
                                                                every: every,
                                                                trim: trim,
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 1 hr to fix
                                                            build/hilo-legacy.js on lines 3410..3421
                                                            src/core.js on lines 70..81

                                                            Duplicated Code

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

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

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

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

                                                              var isPrimitive = function isPrimitive(input) {
                                                                var type = typeof input;
                                                                
                                                                return (
                                                                  input === null ||
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 1 hr to fix
                                                            build/hilo-legacy.js on lines 3124..3134
                                                            src/util.js on lines 31..41

                                                            Duplicated Code

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

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

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

                                                            Tuning

                                                            This issue has a mass of 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 3 locations. Consider refactoring.
                                                            Open

                                                              select = select || function (selector, root) {
                                                            
                                                                // Set root to given root or document
                                                                root = root || doc;
                                                            
                                                            
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 55 mins to fix
                                                            build/hilo-legacy.js on lines 3348..3355
                                                            src/core.js on lines 8..15

                                                            Duplicated Code

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

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

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

                                                            Tuning

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

                                                              var toObject = function toObject (o) {
                                                                if (typeof o === "undefined") { // this matches both null and undefined
                                                                  throw new TypeError("can't convert "+o+" to object");
                                                                }
                                                            
                                                            
                                                            Severity: Major
                                                            Found in build/hilo.js and 2 other locations - About 50 mins to fix
                                                            build/hilo-legacy.js on lines 3102..3108
                                                            src/util.js on lines 9..15

                                                            Duplicated Code

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

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

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

                                                            Tuning

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

                                                              var contains = function contains (haystack, needle) {
                                                                var position = arguments[1];
                                                            
                                                                return haystack.indexOf(needle, position) !== -1;
                                                              };
                                                            Severity: Minor
                                                            Found in build/hilo.js and 2 other locations - About 35 mins to fix
                                                            build/hilo-legacy.js on lines 3299..3303
                                                            src/util.js on lines 206..210

                                                            Duplicated Code

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

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

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

                                                              function Test (con, neg) {
                                                                this.con = con;
                                                                
                                                                if (neg) {
                                                                  this.neg = true;
                                                            Severity: Minor
                                                            Found in build/hilo.js and 2 other locations - About 30 mins to fix
                                                            build/hilo-legacy.js on lines 3479..3485
                                                            src/test.js on lines 49..55

                                                            Duplicated Code

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

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

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