mocha 10.5.2 → 10.6.1

package/README.md

@@ -7,7 +7,6 @@
 <p align="center">
 <a href="https://github.com/mochajs/mocha/actions?query=workflow%3ATests+branch%3Amain"><img src="https://github.com/mochajs/mocha/workflows/Tests/badge.svg?branch=main" alt="GitHub Actions Build Status"></a>
 <a href="https://coveralls.io/github/mochajs/mocha"><img src="https://coveralls.io/repos/github/mochajs/mocha/badge.svg" alt="Coverage Status"></a>
-<a href="https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmochajs%2Fmocha?ref=badge_shield"><img src="https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmochajs%2Fmocha.svg?type=shield" alt="FOSSA Status"></a>
 <a href="https://discord.gg/KeDn2uXhER"><img alt="Chat - Discord" src="https://img.shields.io/badge/chat-Discord-5765F2.svg" /></a>
 <a href="https://github.com/mochajs/mocha#sponsors"><img src="https://opencollective.com/mochajs/tiers/sponsors/badge.svg" alt="OpenCollective Sponsors"></a>
 <a href="https://github.com/mochajs/mocha#backers"><img src="https://opencollective.com/mochajs/tiers/backers/badge.svg" alt="OpenCollective Backers"></a>

package/lib/runnable.js

@@ -20,6 +20,8 @@ var setTimeout = global.setTimeout;
 var clearTimeout = global.clearTimeout;
 var toString = Object.prototype.toString;
 
+var MAX_TIMEOUT = Math.pow(2, 31) - 1;
+
 module.exports = Runnable;
 
 /**
@@ -95,8 +97,7 @@ Runnable.prototype.timeout = function (ms) {
   }
 
   // Clamp to range
-  var INT_MAX = Math.pow(2, 31) - 1;
-  var range = [0, INT_MAX];
+  var range = [0, MAX_TIMEOUT];
   ms = utils.clamp(ms, range);
 
   // see #1652 for reasoning
@@ -233,11 +234,8 @@ Runnable.prototype.clearTimeout = function () {
  */
 Runnable.prototype.resetTimeout = function () {
   var self = this;
-  var ms = this.timeout();
+  var ms = this.timeout() || MAX_TIMEOUT;
 
-  if (ms === 0) {
-    return;
-  }
   this.clearTimeout();
   this.timer = setTimeout(function () {
     if (self.timeout() === 0) {

package/lib/utils.js

@@ -138,7 +138,7 @@ function emptyRepresentation(value, typeHint) {
  * canonicalType(global) // 'global'
  * canonicalType(new String('foo') // 'object'
  * canonicalType(async function() {}) // 'asyncfunction'
- * canonicalType(await import(name)) // 'module'
+ * canonicalType(Object.create(null)) // 'null-prototype'
  */
 var canonicalType = (exports.canonicalType = function canonicalType(value) {
   if (value === undefined) {
@@ -147,7 +147,10 @@ var canonicalType = (exports.canonicalType = function canonicalType(value) {
     return 'null';
   } else if (Buffer.isBuffer(value)) {
     return 'buffer';
+  } else if (Object.getPrototypeOf(value) === null) {
+    return 'null-prototype';
   }
+
   return Object.prototype.toString
     .call(value)
     .replace(/^\[.+\s(.+?)]$/, '$1')
@@ -213,7 +216,7 @@ exports.type = function type(value) {
 exports.stringify = function (value) {
   var typeHint = canonicalType(value);
 
-  if (!~['object', 'array', 'function'].indexOf(typeHint)) {
+  if (!~['object', 'array', 'function', 'null-prototype'].indexOf(typeHint)) {
     if (typeHint === 'buffer') {
       var json = Buffer.prototype.toJSON.call(value);
       // Based on the toJSON result
@@ -399,8 +402,12 @@ exports.canonicalize = function canonicalize(value, stack, typeHint) {
         break;
       }
     /* falls through */
+    case 'null-prototype':
     case 'object':
       canonicalizedObj = canonicalizedObj || {};
+      if (typeHint === 'null-prototype' && Symbol.toStringTag in value) {
+        canonicalizedObj['[Symbol.toStringTag]'] = value[Symbol.toStringTag];
+      }
       withStack(value, function () {
         Object.keys(value)
           .sort()

package/mocha.js

@@ -1,4 +1,4 @@
-// mocha@10.5.2 in javascript ES2018
+// mocha@10.6.1 in javascript ES2018
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
@@ -5820,6 +5820,8 @@
     /*istanbul ignore end*/
     diff: function diff(oldString, newString) {
       /*istanbul ignore start*/
+      var _options$timeout;
+
       var
       /*istanbul ignore end*/
       options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -5853,84 +5855,123 @@
           oldLen = oldString.length;
       var editLength = 1;
       var maxEditLength = newLen + oldLen;
+
+      if (options.maxEditLength) {
+        maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+      }
+
+      var maxExecutionTime =
+      /*istanbul ignore start*/
+      (_options$timeout =
+      /*istanbul ignore end*/
+      options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
+      var abortAfterTimestamp = Date.now() + maxExecutionTime;
       var bestPath = [{
-        newPos: -1,
-        components: []
+        oldPos: -1,
+        lastComponent: undefined
       }]; // Seed editLength = 0, i.e. the content starts with the same values
 
-      var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+      var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);
 
-      if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+      if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
         // Identity per the equality and tokenizer
         return done([{
           value: this.join(newString),
           count: newString.length
         }]);
-      } // Main worker method. checks all permutations of a given edit length for acceptance.
-
+      } // Once we hit the right edge of the edit graph on some diagonal k, we can
+      // definitely reach the end of the edit graph in no more than k edits, so
+      // there's no point in considering any moves to diagonal k+1 any more (from
+      // which we're guaranteed to need at least k+1 more edits).
+      // Similarly, once we've reached the bottom of the edit graph, there's no
+      // point considering moves to lower diagonals.
+      // We record this fact by setting minDiagonalToConsider and
+      // maxDiagonalToConsider to some finite value once we've hit the edge of
+      // the edit graph.
+      // This optimization is not faithful to the original algorithm presented in
+      // Myers's paper, which instead pointlessly extends D-paths off the end of
+      // the edit graph - see page 7 of Myers's paper which notes this point
+      // explicitly and illustrates it with a diagram. This has major performance
+      // implications for some common scenarios. For instance, to compute a diff
+      // where the new text simply appends d characters on the end of the
+      // original text of length n, the true Myers algorithm will take O(n+d^2)
+      // time while this optimization needs only O(n+d) time.
+
+
+      var minDiagonalToConsider = -Infinity,
+          maxDiagonalToConsider = Infinity; // Main worker method. checks all permutations of a given edit length for acceptance.
 
       function execEditLength() {
-        for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
+        for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
           var basePath =
           /*istanbul ignore start*/
           void 0
           /*istanbul ignore end*/
           ;
+          var removePath = bestPath[diagonalPath - 1],
+              addPath = bestPath[diagonalPath + 1];
 
-          var addPath = bestPath[diagonalPath - 1],
-              removePath = bestPath[diagonalPath + 1],
-              _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
-
-          if (addPath) {
+          if (removePath) {
             // No one else is going to attempt to use this value, clear it
             bestPath[diagonalPath - 1] = undefined;
           }
 
-          var canAdd = addPath && addPath.newPos + 1 < newLen,
-              canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
+          var canAdd = false;
+
+          if (addPath) {
+            // what newPos will be after we do an insertion:
+            var addPathNewPos = addPath.oldPos - diagonalPath;
+            canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+          }
+
+          var canRemove = removePath && removePath.oldPos + 1 < oldLen;
 
           if (!canAdd && !canRemove) {
             // If this path is a terminal then prune
             bestPath[diagonalPath] = undefined;
             continue;
           } // Select the diagonal that we want to branch from. We select the prior
-          // path whose position in the new string is the farthest from the origin
+          // path whose position in the old string is the farthest from the origin
           // and does not pass the bounds of the diff graph
+          // TODO: Remove the `+ 1` here to make behavior match Myers algorithm
+          //       and prefer to order removals before insertions.
 
 
-          if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
-            basePath = clonePath(removePath);
-            self.pushComponent(basePath.components, undefined, true);
+          if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {
+            basePath = self.addToPath(addPath, true, undefined, 0);
           } else {
-            basePath = addPath; // No need to clone, we've pulled it from the list
-
-            basePath.newPos++;
-            self.pushComponent(basePath.components, true, undefined);
+            basePath = self.addToPath(removePath, undefined, true, 1);
           }
 
-          _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done
+          newPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
 
-          if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
-            return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
+          if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+            // If we have hit the end of both strings, then we are done
+            return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
           } else {
-            // Otherwise track this path as a potential candidate and continue.
             bestPath[diagonalPath] = basePath;
+
+            if (basePath.oldPos + 1 >= oldLen) {
+              maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+            }
+
+            if (newPos + 1 >= newLen) {
+              minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+            }
           }
         }
 
         editLength++;
       } // Performs the length of edit iteration. Is a bit fugly as this has to support the
       // sync and async mode which is never fun. Loops over execEditLength until a value
-      // is produced.
+      // is produced, or until the edit length exceeds options.maxEditLength (if given),
+      // in which case it will return undefined.
 
 
       if (callback) {
         (function exec() {
           setTimeout(function () {
-            // This should not happen, but we want to be safe.
-
-            /* istanbul ignore next */
-            if (editLength > maxEditLength) {
+            if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
               return callback();
             }
 
@@ -5940,7 +5981,7 @@
           }, 0);
         })();
       } else {
-        while (editLength <= maxEditLength) {
+        while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
           var ret = execEditLength();
 
           if (ret) {
@@ -5953,23 +5994,29 @@
     /*istanbul ignore start*/
 
     /*istanbul ignore end*/
-    pushComponent: function pushComponent(components, added, removed) {
-      var last = components[components.length - 1];
+    addToPath: function addToPath(path, added, removed, oldPosInc) {
+      var last = path.lastComponent;
 
       if (last && last.added === added && last.removed === removed) {
-        // We need to clone here as the component clone operation is just
-        // as shallow array clone
-        components[components.length - 1] = {
-          count: last.count + 1,
-          added: added,
-          removed: removed
+        return {
+          oldPos: path.oldPos + oldPosInc,
+          lastComponent: {
+            count: last.count + 1,
+            added: added,
+            removed: removed,
+            previousComponent: last.previousComponent
+          }
         };
       } else {
-        components.push({
-          count: 1,
-          added: added,
-          removed: removed
-        });
+        return {
+          oldPos: path.oldPos + oldPosInc,
+          lastComponent: {
+            count: 1,
+            added: added,
+            removed: removed,
+            previousComponent: last
+          }
+        };
       }
     },
 
@@ -5979,8 +6026,8 @@
     extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
       var newLen = newString.length,
           oldLen = oldString.length,
-          newPos = basePath.newPos,
-          oldPos = newPos - diagonalPath,
+          oldPos = basePath.oldPos,
+          newPos = oldPos - diagonalPath,
           commonCount = 0;
 
       while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
@@ -5990,13 +6037,14 @@
       }
 
       if (commonCount) {
-        basePath.components.push({
-          count: commonCount
-        });
+        basePath.lastComponent = {
+          count: commonCount,
+          previousComponent: basePath.lastComponent
+        };
       }
 
-      basePath.newPos = newPos;
-      return oldPos;
+      basePath.oldPos = oldPos;
+      return newPos;
     },
 
     /*istanbul ignore start*/
@@ -6047,7 +6095,20 @@
     }
   };
 
-  function buildValues(diff, components, newString, oldString, useLongestToken) {
+  function buildValues(diff, lastComponent, newString, oldString, useLongestToken) {
+    // First we convert our linked list of components in reverse order to an
+    // array in the right order:
+    var components = [];
+    var nextComponent;
+
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+
+    components.reverse();
     var componentPos = 0,
         componentLen = components.length,
         newPos = 0,
@@ -6090,23 +6151,16 @@
     // This is only available for string mode.
 
 
-    var lastComponent = components[componentLen - 1];
+    var finalComponent = components[componentLen - 1];
 
-    if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
-      components[componentLen - 2].value += lastComponent.value;
+    if (componentLen > 1 && typeof finalComponent.value === 'string' && (finalComponent.added || finalComponent.removed) && diff.equals('', finalComponent.value)) {
+      components[componentLen - 2].value += finalComponent.value;
       components.pop();
     }
 
     return components;
   }
 
-  function clonePath(path) {
-    return {
-      newPos: path.newPos,
-      components: path.components.slice(0)
-    };
-  }
-
   }(base));
 
   var character = {};
@@ -6322,6 +6376,11 @@
 
   /*istanbul ignore end*/
   lineDiff.tokenize = function (value) {
+    if (this.options.stripTrailingCr) {
+      // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior
+      value = value.replace(/\r\n/g, '\n');
+    }
+
     var retLines = [],
         linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line
 
@@ -7042,7 +7101,7 @@
         var line = _hunk.lines[j],
             operation = line.length > 0 ? line[0] : ' ',
             content = line.length > 0 ? line.substr(1) : line,
-            delimiter = _hunk.linedelimiters[j];
+            delimiter = _hunk.linedelimiters && _hunk.linedelimiters[j] || '\n';
 
         if (operation === ' ') {
           _toPos++;
@@ -7184,6 +7243,11 @@
     diffLines)
     /*istanbul ignore end*/
     (oldStr, newStr, options);
+
+    if (!diff) {
+      return;
+    }
+
     diff.push({
       value: '',
       lines: []
@@ -7360,6 +7424,10 @@
   }
 
   function formatPatch(diff) {
+    if (Array.isArray(diff)) {
+      return diff.map(formatPatch).join('\n');
+    }
+
     var ret = [];
 
     if (diff.oldFileName == diff.newFileName) {
@@ -8038,6 +8106,70 @@
     };
   }
 
+  var reverse = {};
+
+  /*istanbul ignore start*/
+
+  Object.defineProperty(reverse, "__esModule", {
+    value: true
+  });
+  reverse.reversePatch = reversePatch;
+
+  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  /*istanbul ignore end*/
+  function reversePatch(structuredPatch) {
+    if (Array.isArray(structuredPatch)) {
+      return structuredPatch.map(reversePatch).reverse();
+    }
+
+    return (
+      /*istanbul ignore start*/
+      _objectSpread(_objectSpread({},
+      /*istanbul ignore end*/
+      structuredPatch), {}, {
+        oldFileName: structuredPatch.newFileName,
+        oldHeader: structuredPatch.newHeader,
+        newFileName: structuredPatch.oldFileName,
+        newHeader: structuredPatch.oldHeader,
+        hunks: structuredPatch.hunks.map(function (hunk) {
+          return {
+            oldLines: hunk.newLines,
+            oldStart: hunk.newStart,
+            newLines: hunk.oldLines,
+            newStart: hunk.oldStart,
+            linedelimiters: hunk.linedelimiters,
+            lines: hunk.lines.map(function (l) {
+              if (l.startsWith('-')) {
+                return (
+                  /*istanbul ignore start*/
+                  "+".concat(
+                  /*istanbul ignore end*/
+                  l.slice(1))
+                );
+              }
+
+              if (l.startsWith('+')) {
+                return (
+                  /*istanbul ignore start*/
+                  "-".concat(
+                  /*istanbul ignore end*/
+                  l.slice(1))
+                );
+              }
+
+              return l;
+            })
+          };
+        })
+      })
+    );
+  }
+
   var dmp = {};
 
   /*istanbul ignore start*/
@@ -8211,6 +8343,12 @@
       return _merge.merge;
     }
   });
+  Object.defineProperty(exports, "reversePatch", {
+    enumerable: true,
+    get: function get() {
+      return _reverse.reversePatch;
+    }
+  });
   Object.defineProperty(exports, "structuredPatch", {
     enumerable: true,
     get: function get() {
@@ -8229,6 +8367,12 @@
       return _create.createPatch;
     }
   });
+  Object.defineProperty(exports, "formatPatch", {
+    enumerable: true,
+    get: function get() {
+      return _create.formatPatch;
+    }
+  });
   Object.defineProperty(exports, "convertChangesToDMP", {
     enumerable: true,
     get: function get() {
@@ -8309,6 +8453,12 @@
   /*istanbul ignore end*/
   ;
 
+  var
+  /*istanbul ignore start*/
+  _reverse = reverse
+  /*istanbul ignore end*/
+  ;
+
   var
   /*istanbul ignore start*/
   _create = create
@@ -10951,7 +11101,7 @@
    * canonicalType(global) // 'global'
    * canonicalType(new String('foo') // 'object'
    * canonicalType(async function() {}) // 'asyncfunction'
-   * canonicalType(await import(name)) // 'module'
+   * canonicalType(Object.create(null)) // 'null-prototype'
    */
   var canonicalType = (exports.canonicalType = function canonicalType(value) {
     if (value === undefined) {
@@ -10960,7 +11110,10 @@
       return 'null';
     } else if (isBuffer(value)) {
       return 'buffer';
+    } else if (Object.getPrototypeOf(value) === null) {
+      return 'null-prototype';
     }
+
     return Object.prototype.toString
       .call(value)
       .replace(/^\[.+\s(.+?)]$/, '$1')
@@ -11026,7 +11179,7 @@
   exports.stringify = function (value) {
     var typeHint = canonicalType(value);
 
-    if (!~['object', 'array', 'function'].indexOf(typeHint)) {
+    if (!~['object', 'array', 'function', 'null-prototype'].indexOf(typeHint)) {
       if (typeHint === 'buffer') {
         var json = Buffer.prototype.toJSON.call(value);
         // Based on the toJSON result
@@ -11212,8 +11365,12 @@
           break;
         }
       /* falls through */
+      case 'null-prototype':
       case 'object':
         canonicalizedObj = canonicalizedObj || {};
+        if (typeHint === 'null-prototype' && Symbol.toStringTag in value) {
+          canonicalizedObj['[Symbol.toStringTag]'] = value[Symbol.toStringTag];
+        }
         withStack(value, function () {
           Object.keys(value)
             .sort()
@@ -12810,6 +12967,8 @@
   var clearTimeout$1 = commonjsGlobal.clearTimeout;
   var toString = Object.prototype.toString;
 
+  var MAX_TIMEOUT = Math.pow(2, 31) - 1;
+
   var runnable = Runnable$3;
 
   /**
@@ -12885,8 +13044,7 @@
     }
 
     // Clamp to range
-    var INT_MAX = Math.pow(2, 31) - 1;
-    var range = [0, INT_MAX];
+    var range = [0, MAX_TIMEOUT];
     ms = utils$2.clamp(ms, range);
 
     // see #1652 for reasoning
@@ -13023,11 +13181,8 @@
    */
   Runnable$3.prototype.resetTimeout = function () {
     var self = this;
-    var ms = this.timeout();
+    var ms = this.timeout() || MAX_TIMEOUT;
 
-    if (ms === 0) {
-      return;
-    }
     this.clearTimeout();
     this.timer = setTimeout$2(function () {
       if (self.timeout() === 0) {
@@ -19019,7 +19174,7 @@
   };
 
   var name = "mocha";
-  var version = "10.5.2";
+  var version = "10.6.1";
   var homepage = "https://mochajs.org/";
   var notifyLogo = "https://ibin.co/4QuRuGjXvl36.png";
   var require$$17 = {