mar10/fancytree

File qunit.js has 5406 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*!
 * QUnit 2.19.1
 * https://qunitjs.com/
 *
 * Copyright OpenJS Foundation and other contributors

Function UMD has 683 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      })(commonjsGlobal, function UMD() {
        function fuzzysortNew(instanceOptions) {
          var fuzzysort = {
            single: function single(search, target, options) {
              if (search == 'farzher') return {

Function diff has 628 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    QUnit.diff = function () {
      function DiffMatchPatch() {} //  DIFF FUNCTIONS
  
      /**
       * The data structure representing a diff is an array of tuples:

Function fuzzysortNew has 595 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        function fuzzysortNew(instanceOptions) {
          var fuzzysort = {
            single: function single(search, target, options) {
              if (search == 'farzher') return {
                target: "farzher was here (^-^*)/",

Function Assert has 330 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var Assert = /*#__PURE__*/function () {
      function Assert(testContext) {
        _classCallCheck(this, Assert);
  
        this.test = testContext;

Function dump has 213 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var dump = (function () {
      function quote(str) {
        return '"' + str.toString().replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
      }
  

Function equiv has 178 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var equiv = (function () {
      // Value pairs queued for comparison. Used for breadth-first processing order, recursion
      // detection and avoiding repeated comparison (see below for details).
      // Elements are { a: val, b: val }.
      var pairs = [];

Function toolbarModuleFilter has 138 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      function toolbarModuleFilter(beginDetails) {
        var initialSelected = null;
        dropdownData = {
          options: beginDetails.modules.slice(),
          selectedMap: new StringMap(),

Function goAsync has 133 lines of code (exceeds 25 allowed). Consider refactoring.

Open

            goAsync: function goAsync(search, targets, options) {
              var canceled = false;
              var p = new Promise(function (resolve, reject) {
                if (search == 'farzher') return resolve([{
                  target: "farzher was here (^-^*)/",

Function p has 126 lines of code (exceeds 25 allowed). Consider refactoring.

Open

              var p = new Promise(function (resolve, reject) {
                if (search == 'farzher') return resolve([{
                  target: "farzher was here (^-^*)/",
                  score: 0,
                  indexes: [0, 1, 2, 3, 4, 5, 6],

Function SuiteReport has 117 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var SuiteReport = /*#__PURE__*/function () {
      function SuiteReport(name, parentSuite) {
        _classCallCheck(this, SuiteReport);
  
        this.name = name;

Function step has 106 lines of code (exceeds 25 allowed). Consider refactoring.

Open

                function step() {
                  if (canceled) return reject('canceled');
                  var startMs = Date.now(); // This code is copy/pasted 3 times for performance reasons [options.keys, options.key, no keys]
                  // options.keys
  

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

Open

    var TapReporter = /*#__PURE__*/function () {
      function TapReporter(runner) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
        _classCallCheck(this, TapReporter);

Function algorithm has 101 lines of code (exceeds 25 allowed). Consider refactoring.

Open

            algorithm: function algorithm(searchLowerCodes, prepared, searchLowerCode) {
              var targetLowerCodes = prepared._targetLowerCodes;
              var searchLen = searchLowerCodes.length;
              var targetLen = targetLowerCodes.length;
              var searchI = 0; // where we at

Function go has 96 lines of code (exceeds 25 allowed). Consider refactoring.

Open

            go: function go(search, targets, options) {
              if (search == 'farzher') return [{
                target: "farzher was here (^-^*)/",
                score: 0,
                indexes: [0, 1, 2, 3, 4, 5, 6],

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

Open

      finish: function finish() {
        config.current = this; // Release the test callback to ensure that anything referenced has been
        // released to be garbage collected.
  
        this.callback = undefined;

Function TestReport has 93 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var TestReport = /*#__PURE__*/function () {
      function TestReport(name, suite, options) {
        _classCallCheck(this, TestReport);
  
        this.name = name;

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

Open

      DiffMatchPatch.prototype.diffCleanupMerge = function (diffs) {
        var pointer, countDelete, countInsert, textInsert, textDelete, commonlength, changes, diffPointer, position;
        diffs.push([DIFF_EQUAL, '']); // Add a dummy entry at the end.
  
        pointer = 0;

Function diffBisect has 82 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      DiffMatchPatch.prototype.diffBisect = function (text1, text2, deadline) {
        var text1Length, text2Length, maxD, vOffset, vLength, v1, v2, x, delta, front, k1start, k1end, k2start, k2end, k2Offset, k1Offset, x1, x2, y1, y2, d, k1, k2; // Cache the text lengths to prevent multiple calls.
  
        text1Length = text1.length;
        text2Length = text2.length;

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

Open

      DiffMatchPatch.prototype.diffCleanupSemantic = function (diffs) {
        var changes, equalities, equalitiesLength, lastequality, pointer, lengthInsertions2, lengthDeletions2, lengthInsertions1, lengthDeletions1, deletion, insertion, overlapLength1, overlapLength2;
        changes = false;
        equalities = []; // Stack of indices where equalities are found.
  

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

Open

            algorithmNoTypo: function algorithmNoTypo(searchLowerCodes, prepared, searchLowerCode) {
              var targetLowerCodes = prepared._targetLowerCodes;
              var searchLen = searchLowerCodes.length;
              var targetLen = targetLowerCodes.length;
              var searchI = 0; // where we at

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

Open

    function Test(settings) {
      this.expected = null;
      this.assertions = [];
      this.module = config.currentModule;
      this.steps = [];

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

Open

      DiffMatchPatch.prototype.diffHalfMatch = function (text1, text2) {
        var longtext, shorttext, dmp, text1A, text2B, text2A, text1B, midCommon, hm1, hm2, hm;
        longtext = text1.length > text2.length ? text1 : text2;
        shorttext = text1.length > text2.length ? text2 : text1;
  

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

Open

      internalStop: function internalStop() {
        var requiredCalls = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
        config.blocking = true;
        var test = this;
        var pauseId = this.nextPauseId++;

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

Open

      function toolbarChanged() {
        var field = this;
        var params = {}; // Detect if field is a select menu or a checkbox
  
        var value;

Function diffCleanupEfficiency has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      DiffMatchPatch.prototype.diffCleanupEfficiency = function (diffs) {
        var changes, equalities, equalitiesLength, lastequality, pointer, preIns, preDel, postIns, postDel;
        changes = false;
        equalities = []; // Stack of indices where equalities are found.
  

Function _createForOfIteratorHelper has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function _createForOfIteratorHelper(o, allowArrayLike) {
      var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
  
      if (!it) {
        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {

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

Open

    function done() {
      // We have reached the end of the processing queue and are about to emit the
      // "runEnd" event after which reporters typically stop listening and exit
      // the process. First, check if we need to emit one final test.
      if (config.stats.testCount === 0 && config.failOnZeroTests === true) {

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

Open

      DiffMatchPatch.prototype.diffLineMode = function (text1, text2, deadline) {
        var a, diffs, linearray, pointer, countInsert, countDelete, textInsert, textDelete, j; // Scan the text on a line-by-line basis first.
  
        a = this.diffLinesToChars(text1, text2);
        text1 = a.chars1;

Function ConsoleReporter has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var ConsoleReporter = /*#__PURE__*/function () {
      function ConsoleReporter(runner) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
        _classCallCheck(this, ConsoleReporter);

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

Open

    function prettyYamlValue(value) {
      var indent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4;
  
      if (value === undefined) {
        // Not supported in JSON/YAML, turn into string

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

Open

    var StringMap = typeof g.Map === 'function' && typeof g.Map.prototype.keys === 'function' && typeof g.Symbol === 'function' && _typeof(g.Symbol.iterator) === 'symbol' ? g.Map : function StringMap(input) {
      var _this = this;
  
      var store = Object.create(null);
      var hasOwn = Object.prototype.hasOwnProperty;

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

Open

        value: function rejects(promise, expected, message) {
          var _validateExpectedExce3 = validateExpectedExceptionArgs(expected, message, 'rejects');
  
          var _validateExpectedExce4 = _slicedToArray(_validateExpectedExce3, 2);
  

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

Open

      valid: function valid() {
        // Internally-generated tests are always valid
        if (this.callback && this.callback.validTest) {
          return true;
        }

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

Open

      function allSettled(arr) {
        var P = this;
        return new P(function (resolve, reject) {
          if (!(arr && typeof arr.length !== 'undefined')) {
            return reject(new TypeError(_typeof(arr) + ' ' + arr + ' is not iterable(cannot read property Symbol(Symbol.iterator))'));

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

Open

      function getUrlConfigHtml() {
        var selection = false;
        var urlConfig = config.urlConfig;
        var urlConfigHtml = '';
  

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

Open

        value: function throws(block, expected, message) {
          var _validateExpectedExce = validateExpectedExceptionArgs(expected, message, 'throws');
  
          var _validateExpectedExce2 = _slicedToArray(_validateExpectedExce, 2);
  

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

Open

    function createModule(name, testEnvironment, modifiers) {
      var parentModule = moduleStack.length ? moduleStack.slice(-1)[0] : null;
      var moduleName = parentModule !== null ? [parentModule.name, name].join(' > ') : name;
      var parentSuite = parentModule ? parentModule.suiteReport : runSuite;
      var skip = parentModule !== null && parentModule.skip || modifiers.skip;

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

Open

      DiffMatchPatch.prototype.diffCompute = function (text1, text2, checklines, deadline) {
        var diffs, longtext, shorttext, i, hm, text1A, text2A, text1B, text2B, midCommon, diffsA, diffsB;
  
        if (!text1) {
          // Just add some text (speedup).

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

Open

            highlightCallback: function highlightCallback(result, cb) {
              if (result === null) return null;
              var target = result.target;
              var targetLen = target.length;
              var indexes = result.indexes;

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

Open

      before: function before() {
        var _this = this;
  
        var module = this.module;
        var notStartedModules = getNotStartedModules(module); // ensure the callbacks are executed serially for each module

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

Open

      DiffMatchPatch.prototype.diffLinesToChars = function (text1, text2) {
        var lineArray, lineHash, chars1, chars2;
        lineArray = []; // E.g. lineArray[4] === 'Hello\n'
  
        lineHash = {}; // E.g. lineHash['Hello\n'] === 4

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

Open

      DiffMatchPatch.prototype.DiffMain = function (text1, text2, optChecklines) {
        var deadline, checklines, commonlength, commonprefix, commonsuffix, diffs; // The diff must be complete in up to 1 second.
  
        deadline = new Date().getTime() + 1000; // Check for null inputs.
  

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

Open

    function processModule(name, options, executeNow) {
      var modifiers = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
  
      if (typeof options === 'function') {
        executeNow = options;

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

Open

      pushResult: function pushResult(resultInfo) {
        if (this !== config.current) {
          var message = resultInfo && resultInfo.message || '';
          var testName = this && this.testName || '';
          var error = 'Assertion occurred after test finished.\n' + '> Test: ' + testName + '\n' + '> Message: ' + message + '\n';

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

Open

    function chain(has, keys) {
      var ctx = {
        has: has,
        keys: keys
      };

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

Open

            highlight: function highlight(result, hOpen, hClose) {
              if (typeof hOpen == 'function') return fuzzysort.highlightCallback(result, hOpen);
              if (result === null) return null;
              if (hOpen === undefined) hOpen = '<b>';
              if (hClose === undefined) hClose = '</b>';

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

Open

        var fastpriorityqueue = function fastpriorityqueue() {
          var r = [],
              o = 0,
              e = {};
  

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

Open

      Promise.all = function (arr) {
        return new Promise(function (resolve, reject) {
          if (!isArray(arr)) {
            return reject(new TypeError('Promise.all accepts an array'));
          }

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

Open

      DiffMatchPatch.prototype.diffCommonOverlap = function (text1, text2) {
        var text1Length, text2Length, textLength, best, length, pattern, found; // Cache the text lengths to prevent multiple calls.
  
        text1Length = text1.length;
        text2Length = text2.length; // Eliminate the null case.

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

Open

    function exportQUnit(QUnit) {
      var exportedModule = false;
  
      if (window$1 && document) {
        // QUnit may be defined when it is preconfigured but then only QUnit and QUnit.config may be defined.

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

Open

      queueHook: function queueHook(hook, hookName, hookOwner) {
        var _this3 = this;
  
        var callHook = function callHook() {
          var promise = hook.call(_this3.testEnvironment, _this3.assert);

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

Open

    function objectType(obj) {
      if (typeof obj === 'undefined') {
        return 'undefined';
      } // Consider: typeof null === object
  

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

Open

      run: function run() {
        config.current = this;
  
        if (config.notrycatch) {
          runTest(this);

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

Open

    function decycledShallowClone(object) {
      var ancestors = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  
      if (ancestors.indexOf(object) !== -1) {
        return '[Circular]';

Consider simplifying this complex logical expression.

Open

            if (lastequality && (preIns && preDel && postIns && postDel || lastequality.length < 2 && preIns + preDel + postIns + postDel === 3)) {
              // Duplicate record.
              diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastequality]); // Change second copy to insert.
  
              diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;

Avoid deeply nested control flow statements.

Open

                        if (Date.now() - startMs >= 10
                        /*asyncInterval*/
                        ) {
                          isNode ? setImmediate(step) : setTimeout(step);
                          return;

Avoid deeply nested control flow statements.

Open

                    if (searchI === searchLen) {
                      successStrict = true;
                      break;
                    }

Avoid deeply nested control flow statements.

Open

                        if (Date.now() - startMs >= 10
                        /*asyncInterval*/
                        ) {
                          isNode ? setImmediate(step) : setTimeout(step);
                          return;

Avoid deeply nested control flow statements.

Open

                      if (typoSimpleI === 1) return null; // reached the end of the line for transposing

Avoid deeply nested control flow statements.

Open

                        if (result.score > q.peek().score) q.replaceTop(result);

Avoid deeply nested control flow statements.

Open

                    if (searchLowerCodes[typoStrictI] === searchLowerCodes[typoStrictI + 1]) continue; // doesn't make sense to transpose a repeat char

Avoid deeply nested control flow statements.

Open

                    if (typoStrictI > searchLen - 2) break;

Avoid deeply nested control flow statements.

Open

                if (classNameHasPass || classNameHasSkipped) {
                  hiddenTests.push(test);
                }

Avoid deeply nested control flow statements.

Open

                if (x1 >= x2) {
                  // Overlap detected.
                  return this.diffBisectSplit(text1, text2, x1, y1, deadline);
                }

Avoid deeply nested control flow statements.

Open

                      if (searchLowerCode === searchLowerCodeNew) continue; // doesn't make sense to transpose a repeat char

Avoid deeply nested control flow statements.

Open

                  if (commonlength !== 0) {
                    if (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === DIFF_EQUAL) {
                      diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(0, commonlength);
                    } else {
                      diffs.splice(0, 0, [DIFF_EQUAL, textInsert.substring(0, commonlength)]);

Avoid deeply nested control flow statements.

Open

                  if (commonlength !== 0) {
                    diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1];
                    textInsert = textInsert.substring(0, textInsert.length - commonlength);
                    textDelete = textDelete.substring(0, textDelete.length - commonlength);
                  }

Avoid deeply nested control flow statements.

Open

                      if (searchLowerCode === searchLowerCodeNew) continue; // doesn't make sense to transpose a repeat char

Avoid deeply nested control flow statements.

Open

                        if (result.score > q.peek().score) q.replaceTop(result);

Avoid deeply nested control flow statements.

Open

                    if (searchI === searchLen) {
                      successStrict = true;
                      break;
                    }

Avoid deeply nested control flow statements.

Open

                if (x1 >= x2) {
                  // Overlap detected.
                  return this.diffBisectSplit(text1, text2, x1, y1, deadline);
                }

Avoid deeply nested control flow statements.

Open

                    if (result.score > q.peek().score) q.replaceTop(result);

Avoid deeply nested control flow statements.

Open

                    if (result.score > q.peek().score) q.replaceTop(result);

Avoid deeply nested control flow statements.

Open

                if (hasOwn.call(val.value, _j)) {
                  urlConfigHtml += "<option value='" + escapeText(_j) + "'" + (config[val.id] === _j ? (selection = true) && " selected='selected'" : '') + '>' + escapeText(val.value[_j]) + '</option>';
                }

Consider simplifying this complex logical expression.

Open

        if (value === '' || rSpecialJson.test(value) || rSpecialYaml.test(value[0]) || rUntrimmed.test(value) || rNumerical.test(value) || rBool.test(value)) {
          if (!/\n/.test(value)) {
            // Complex one-line string, use JSON (quoted string)
            return JSON.stringify(value);
          } // See also <https://yaml-multiline.info/>

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

Open

      window$1.onerror = function (message, fileName, lineNumber, columnNumber, errorObj) {

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

Open

        value: function push(result, actual, expected, message, negative) {

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

Open

      DiffMatchPatch.prototype.diffBisectSplit = function (text1, text2, x, y, deadline) {

Avoid too many return statements within this function.

Open

        return regexFilter ? this.regexFilter(!!regexFilter[1], regexFilter[2], regexFilter[3], fullName) : this.stringFilter(filter, fullName);

Avoid too many return statements within this function.

Open

          return true;

Avoid too many return statements within this function.

Open

          return value;

Avoid too many return statements within this function.

Open

      return JSON.stringify(decycledShallowClone(value), null, 2);

Avoid too many return statements within this function.

Open

                  if (resultsLen === 0) return resolve(noResults);

Avoid too many return statements within this function.

Open

          return this.diffLineMode(text1, text2, deadline);

Avoid too many return statements within this function.

Open

        return this.diffBisect(text1, text2, deadline);

Avoid too many return statements within this function.

Open

          return diffsA.concat([[DIFF_EQUAL, midCommon]], diffsB);

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

Open

                  for (var keyI = keysLen - 1; keyI >= 0; --keyI) {
                    var key = keys[keyI];
                    var target = getValue(obj, key);
  
                    if (!target) {

• Read up
  Read up

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

Open

                      for (var keyI = keysLen - 1; keyI >= 0; --keyI) {
                        var key = keys[keyI];
                        var target = getValue(obj, key);
  
                        if (!target) {

• Read up
  Read up

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

Open

            getPrepared: function getPrepared(target) {
              if (target.length > 999) return fuzzysort.prepare(target); // don't cache huge targets
  
              var targetPrepared = preparedCache.get(target);
              if (targetPrepared !== undefined) return targetPrepared;

• Read up
  Read up

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

Open

            getPreparedSearch: function getPreparedSearch(search) {
              if (search.length > 999) return fuzzysort.prepareSearch(search); // don't cache huge searches
  
              var searchPrepared = preparedSearchCache.get(search);
              if (searchPrepared !== undefined) return searchPrepared;

• Read up
  Read up

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

Open

            if (k2 === -d || k2 !== d && v2[k2Offset - 1] < v2[k2Offset + 1]) {
              x2 = v2[k2Offset + 1];
            } else {
              x2 = v2[k2Offset - 1] + 1;
            }

• Read up
  Read up

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

Open

            if (k1 === -d || k1 !== d && v1[k1Offset - 1] < v1[k1Offset + 1]) {
              x1 = v1[k1Offset + 1];
            } else {
              x1 = v1[k1Offset - 1] + 1;
            }

• Read up
  Read up

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

Open

            for (var c = n - 1 >> 1; n > 0 && e.score < r[c].score; c = (n = c) - 1 >> 1) {
              r[n] = r[c];
            }

• Read up
  Read up

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

Open

            for (var a = e - 1 >> 1; e > 0 && n.score < r[a].score; a = (e = a) - 1 >> 1) {
              r[e] = r[a];
            }

• Read up
  Read up

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

Open

                  if (resultsLen < limit) {
                    q.add(result);
                    ++resultsLen;
                  } else {
                    ++limitedCount;

• Read up
  Read up

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

Open

                      if (resultsLen < limit) {
                        q.add(result);
                        ++resultsLen;
                      } else {
                        ++limitedCount;

• Read up
  Read up

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

Open

                      if (resultsLen < limit) {
                        q.add(result);
                        ++resultsLen;
                      } else {
                        ++limitedCount;

• Read up
  Read up

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

Open

                  if (resultsLen < limit) {
                    q.add(result);
                    ++resultsLen;
                  } else {
                    ++limitedCount;

• Read up
  Read up

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

Open

          if (typeof then !== 'function') {
            var _message2 = 'The value provided to `assert.rejects` in ' + '"' + currentTest.testName + '" was not a promise.';
  
            currentTest.assert.pushResult({
              result: false,

• Read up
  Read up

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

Open

          if (typeof block !== 'function') {
            var _message = 'The value provided to `assert.throws` in ' + '"' + currentTest.testName + '" was not a function.';
  
            currentTest.assert.pushResult({
              result: false,

• Read up
  Read up

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

Open

                  if (resultsLen < limit) {
                    q.add(objResults);
                    ++resultsLen;
                  } else {
                    ++limitedCount;

• Read up
  Read up

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

Open

                      if (resultsLen < limit) {
                        q.add(objResults);
                        ++resultsLen;
                      } else {
                        ++limitedCount;

• Read up
  Read up

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

Open

                for (var i = 0; i < searchLen; ++i) {
                  var targetI = matchesBest[i]; // score only goes down if they're not consecutive
  
                  if (lastTargetI !== targetI - 1) score -= targetI;
                  lastTargetI = targetI;

• Read up
  Read up

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

Open

                  if (isMatch) {
                    matchesStrict[matchesStrictLen++] = targetI;
                    ++searchI;
  
                    if (searchI === searchLen) {

• Read up
  Read up

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

Open

                  if (isMatch) {
                    matchesStrict[matchesStrictLen++] = targetI;
                    ++searchI;
  
                    if (searchI === searchLen) {

• Read up
  Read up

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

Open

                for (var i = 0; i < searchLen; ++i) {
                  var targetI = matchesBest[i]; // score only goes down if they're not consecutive
  
                  if (lastTargetI !== targetI - 1) score -= targetI;
                  lastTargetI = targetI;

• Read up
  Read up

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

Open

                      if (iCurrent % 1000
                      /*itemsPerCheck*/
                      === 0) {
                        if (Date.now() - startMs >= 10
                        /*asyncInterval*/

• Read up
  Read up

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

Open

                      if (iCurrent % 1000
                      /*itemsPerCheck*/
                      === 0) {
                        if (Date.now() - startMs >= 10
                        /*asyncInterval*/

• Read up
  Read up

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

Open

                      if (iCurrent % 1000
                      /*itemsPerCheck*/
                      === 0) {
                        if (Date.now() - startMs >= 10
                        /*asyncInterval*/

• Read up
  Read up

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

Open

    test.only.each = function (testName, dataset, callback) {
      runEach(dataset, function (data, testKey) {
        addOnlyTest({
          testName: makeEachTestName(testName, testKey),
          callback: callback,

• Read up
  Read up

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

Open

      }, {
        key: "false",
        value: function _false(result, message) {
          this.pushResult({
            result: result === false,

• Read up
  Read up

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

Open

      each: function each(testName, dataset, callback) {
        runEach(dataset, function (data, testKey) {
          addTest({
            testName: makeEachTestName(testName, testKey),
            callback: callback,

• Read up
  Read up

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

Open

      }, {
        key: "true",
        value: function _true(result, message) {
          this.pushResult({
            result: result === true,

• Read up
  Read up

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

Open

                      result = {
                        target: result.target,
                        _targetLowerCodes: null,
                        _nextBeginningIndexes: null,
                        score: result.score,

• Read up
  Read up

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

Open

                  result = {
                    target: result.target,
                    _targetLowerCodes: null,
                    _nextBeginningIndexes: null,
                    score: result.score,

• Read up
  Read up

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

Open

            this.log($.cyan("not ok ".concat(this.testCount, " # TODO ").concat(test.fullName.join(' > '))));

• Read up
  Read up

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

Open

            this.log($.yellow("ok ".concat(this.testCount, " # SKIP ").concat(test.fullName.join(' > '))));

• Read up
  Read up

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

Open

            this.log($.red("not ok ".concat(this.testCount, " ").concat(test.fullName.join(' > '))));

• Read up
  Read up

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

Open

              var allowTypo = options && options.allowTypo !== undefined ? options.allowTypo : instanceOptions && instanceOptions.allowTypo !== undefined ? instanceOptions.allowTypo : true;

• Read up
  Read up

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

Open

              var allowTypo = options && options.allowTypo !== undefined ? options.allowTypo : instanceOptions && instanceOptions.allowTypo !== undefined ? instanceOptions.allowTypo : true;

• Read up
  Read up

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

Open

                var allowTypo = options && options.allowTypo !== undefined ? options.allowTypo : instanceOptions && instanceOptions.allowTypo !== undefined ? instanceOptions.allowTypo : true;

• Read up
  Read up

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

Open

      function addClass(elem, name) {
        if (!hasClass(elem, name)) {
          elem.className += (elem.className ? ' ' : '') + name;
        }
      }

• Read up
  Read up

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

Open

          if (config.current !== test) {
            throw new Error('Unexpected release of async pause during a different test.\n' + "> Test: ".concat(test.testName, " [async #").concat(pauseId, "]"));
          }

• Read up
  Read up

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

Open

          if (config.current === undefined) {
            throw new Error('Unexpected release of async pause after tests finished.\n' + "> Test: ".concat(test.testName, " [async #").concat(pauseId, "]"));
          }

• Read up
  Read up

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

Open

                  var isMatch = searchLowerCodes[typoStrictI === 0 ? searchI : typoStrictI === searchI ? searchI + 1 : typoStrictI === searchI - 1 ? searchI - 1 : searchI] === targetLowerCodes[targetI];

• Read up
  Read up

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

Open

                  searchLowerCode = searchLowerCodes[typoSimpleI === 0 ? searchI : typoSimpleI === searchI ? searchI + 1 : typoSimpleI === searchI - 1 ? searchI - 1 : searchI];

• Read up
  Read up

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

Open

        if (text1.length > text2.length) {
          text1A = hm[0];
          text1B = hm[1];
          text2A = hm[2];
          text2B = hm[3];

• Read up
  Read up

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

Open

        } else {
          text2A = hm[0];
          text2B = hm[1];
          text1A = hm[2];
          text1B = hm[3];

• Read up
  Read up

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

Open

            currentTest.assert.pushResult({
              result: result,
              // leave rejection value of undefined as-is
              actual: actual && errorString(actual),
              expected: expected,

• Read up
  Read up

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

Open

                for (var i = matchesBestLen - 1; i >= 0; --i) {
                  prepared.indexes[i] = matchesBest[i];
                }

• Read up
  Read up

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

Open

          currentTest.assert.pushResult({
            result: result,
            // undefined if it didn't throw
            actual: actual && errorString(actual),
            expected: expected,

• Read up
  Read up

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

Open

              if (!target) return {
                target: '',
                _targetLowerCodes: [0
                /*this 0 doesn't make sense. here because an empty array causes the algorithm to deoptimize and run 50% slower!*/
                ],

• Read up
  Read up

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

Open

              if (!target) return {
                target: '',
                _targetLowerCodes: [0
                /*this 0 doesn't make sense. here because an empty array causes the algorithm to deoptimize and run 50% slower!*/
                ],

• Read up
  Read up

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

Open

                for (var i = matchesBestLen - 1; i >= 0; --i) {
                  prepared.indexes[i] = matchesBest[i];
                }

• Read up
  Read up

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

Open

                  for (var i = resultsLen - 1; i >= 0; --i) {
                    results[i] = q.poll();
                  }

• Read up
  Read up

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

Open

              for (var i = resultsLen - 1; i >= 0; --i) {
                results[i] = q.poll();
              }

• Read up
  Read up

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

Open

        this.log = options.log || Function.prototype.bind.call(console$1.log, console$1);

• Read up
  Read up

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

Open

        this.log = options.log || Function.prototype.bind.call(console$1.log, console$1);

• Read up
  Read up