wikimedia/mediawiki-core

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

Open

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

Function UMD has 665 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 622 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  QUnit.diff = function () {
    function DiffMatchPatch() {}

    //  DIFF FUNCTIONS

Function fuzzysortNew has 577 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 literal(o) {

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 121 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 114 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 111 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  var SuiteReport = /*#__PURE__*/function () {
    function SuiteReport(name, parentSuite) {
      _classCallCheck(this, SuiteReport);
      this.name = name;
      this.fullName = parentSuite ? parentSuite.fullName.concat(name) : [];

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);
      // Cache references to console methods to ensure we can report failures

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

Open

    finish: function finish() {
      config.current = this;

      // Release the timeout and timeout callback references to be garbage collected.
      // https://github.com/qunitjs/qunit/pull/1708

Function algorithm has 99 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 step has 94 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]

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

Open

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

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

Open

    DiffMatchPatch.prototype.diffCleanupMerge = function (diffs) {
      diffs.push([DIFF_EQUAL, '']); // Add a dummy entry at the end.
      var pointer = 0;
      var countDelete = 0;
      var countInsert = 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;

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

Open

    DiffMatchPatch.prototype.diffCleanupSemantic = function (diffs) {
      var changes = false;
      var equalities = []; // Stack of indices where equalities are found.
      var equalitiesLength = 0; // Keeping our own length var is faster in JS.
      /** @type {?string} */

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 PerfReporter has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

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

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;
      if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {

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

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 _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") {
        if (it) o = it;

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.
      equalitiesLength = 0; // Keeping our own length var is faster in JS.

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

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);
      // Cache references to console methods to ensure we can report failures

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;
    this.has = function (strKey) {

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
      // and let the below output it as bare string.

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 rejects has 37 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);
        expected = _validateExpectedExce4[0];
        message = _validateExpectedExce4[1];

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

Open

    function getUrlConfigHtml() {
      var selection = false;
      var urlConfig = config.urlConfig;
      var urlConfigHtml = '';
      for (var i = 0; i < urlConfig.length; i++) {

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 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 throws has 35 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);
        expected = _validateExpectedExce2[0];
        message = _validateExpectedExce2[1];

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).
        return [[DIFF_INSERT, text2]];

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

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;
      options = undefined;

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

Open

    object: function object(a, b) {
      // Handle memory (skip recursion)
      if (memory.some(function (pair) {
        return pair.a === a && pair.b === b;
      })) {

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

Open

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

      // '\x00' is a valid character, but various debuggers don't like it.

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 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 fastpriorityqueue has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

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

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

Open

    DiffMatchPatch.prototype.DiffMain = function (text1, text2, optChecklines) {
      // The diff must be complete in up to 1 second.
      var deadline = Date.now() + 1000;

      // Check for null inputs.

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

Open

    DiffMatchPatch.prototype.diffCommonOverlap = function (text1, text2) {
      // Cache the text lengths to prevent multiple calls.
      var text1Length = text1.length;
      var text2Length = text2.length;

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

Open

  function objectType(obj) {
    if (typeof obj === 'undefined') {
      return 'undefined';
    }

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.
      if (window$1.QUnit && window$1.QUnit.version) {

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);
        _this3.resolvePromise(promise, hookName);

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

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

Open

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

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.

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 (Date.now() - startMs >= 10 /*asyncInterval*/) {
                        isNode ? setImmediate(step) : setTimeout(step);
                        return;
                      }

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 (searchI === searchLen) {
                    successStrict = true;
                    break;
                  }

Avoid deeply nested control flow statements.

Open

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

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 (Date.now() - startMs >= 10 /*asyncInterval*/) {
                        isNode ? setImmediate(step) : setTimeout(step);
                        return;
                      }

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 (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 (typoStrictI > searchLen - 2) 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 (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 (searchI === searchLen) {
                    successStrict = true;
                    break;
                  }

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>';
              }

Avoid deeply nested control flow statements.

Open

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

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

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

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 diffsA.concat([[DIFF_EQUAL, midCommon]], diffsB);

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 true;

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

      return objTypeCallbacks.array(aProperties.sort(), bProperties.sort());

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 regexFilter ? this.regexFilter(!!regexFilter[1], regexFilter[2], regexFilter[3], fullName) : this.stringFilter(filter, fullName);

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 value;

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) {
                        objResults[keyI] = null;

• 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) {
                    objResults[keyI] = null;

• 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;
            targetPrepared = fuzzysort.prepare(target);

• 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;
            searchPrepared = fuzzysort.prepareSearch(search);

• 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

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) {
                    successStrict = true;

• Read up
  Read up

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

Open

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

• 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*/) {
                        isNode ? setImmediate(step) : setTimeout(step);
                        return;
                      }

• 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*/) {
                        isNode ? setImmediate(step) : setTimeout(step);
                        return;
                      }

• 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*/) {
                        isNode ? setImmediate(step) : setTimeout(step);
                        return;
                      }

• 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

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

• 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

    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

      var assertion = {
        passed: details.result,
        actual: details.actual,
        expected: details.expected,
        message: details.message,

• 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($.red("not ok ".concat(this.testCount, " ").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($.cyan("not ok ".concat(this.testCount, " # TODO ").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

        return extend(this.start(), {
          runtime: this.getRuntime(),
          status: this.getStatus(),
          errors: this.getFailedAssertions(),
          assertions: this.getAssertions()

• Read up
  Read up

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

Open

  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

• 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

        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

      } 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: false,
            message: 'The promise returned by the `assert.rejects` callback in ' + '"' + currentTest.testName + '" did not reject.',
            actual: promise
          });

• Read up
  Read up

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

Open

          currentTest.assert.pushResult({
            result: false,
            message: 'The value provided to `assert.rejects` in ' + '"' + currentTest.testName + '" was not a promise.',
            actual: promise
          });

• 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

                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

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

• 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!*/],
              _nextBeginningIndexes: null,
              score: null,

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

            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!*/],
              _nextBeginningIndexes: null,
              score: null,

• 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

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

      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

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

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

Open

        Object.keys(object).forEach(function (key) {
          clone[key] = decycledShallowClone(object[key], ancestors);
        });

• Read up
  Read up