importmap_mocha-rails 0.3.3 → 0.3.4

data/vendor/javascripts/mocha.js

@@ -1,4 +1,4 @@
-// mocha@10.3.0 in javascript ES2018
+// mocha@10.6.0 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
@@ -11460,6 +11610,39 @@
    */
   exports.getMochaID = obj =>
     obj && typeof obj === 'object' ? obj[MOCHA_ID_PROP_NAME] : undefined;
+
+  /**
+   * Replaces any detected circular dependency with the string '[Circular]'
+   * Mutates original object
+   * @param inputObj {*}
+   * @returns {*}
+   */
+  exports.breakCircularDeps = inputObj => {
+    const seen = new Set();
+
+    function _breakCircularDeps(obj) {
+      if (obj && typeof obj !== 'object') {
+        return obj;
+      }
+
+      if (seen.has(obj)) {
+        return '[Circular]';
+      }
+
+      seen.add(obj);
+      for (const k in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, k)) {
+          obj[k] = _breakCircularDeps(obj[k]);
+        }
+      }
+
+      // deleting means only a seen object that is its own child will be detected
+      seen.delete(obj);
+      return obj;
+    }
+
+    return _breakCircularDeps(inputObj);
+  };
   }(utils$3));
 
   var _nodeResolve_empty = {};
@@ -14433,11 +14616,22 @@
       err = thrown2Error(err);
     }
 
-    try {
-      err.stack =
-        this.fullStackTrace || !err.stack ? err.stack : stackFilter(err.stack);
-    } catch (ignore) {
-      // some environments do not take kindly to monkeying with the stack
+    // Filter the stack traces
+    if (!this.fullStackTrace) {
+      const alreadyFiltered = new Set();
+      let currentErr = err;
+
+      while (currentErr && currentErr.stack && !alreadyFiltered.has(currentErr)) {
+        alreadyFiltered.add(currentErr);
+
+        try {
+          currentErr.stack = stackFilter(currentErr.stack);
+        } catch (ignore) {
+          // some environments do not take kindly to monkeying with the stack
+        }
+
+        currentErr = currentErr.cause;
+      }
     }
 
     this.emit(constants$1.EVENT_TEST_FAIL, test, err);
@@ -15468,6 +15662,56 @@
     }
   });
 
+  /**
+   * Traverses err.cause and returns all stack traces
+   *
+   * @private
+   * @param {Error} err
+   * @param {Set<Error>} [seen]
+   * @return {FullErrorStack}
+   */
+  var getFullErrorStack = function (err, seen) {
+    if (seen && seen.has(err)) {
+      return { message: '', msg: '<circular>', stack: '' };
+    }
+
+    var message;
+
+    if (typeof err.inspect === 'function') {
+      message = err.inspect() + '';
+    } else if (err.message && typeof err.message.toString === 'function') {
+      message = err.message + '';
+    } else {
+      message = '';
+    }
+
+    var msg;
+    var stack = err.stack || message;
+    var index = message ? stack.indexOf(message) : -1;
+
+    if (index === -1) {
+      msg = message;
+    } else {
+      index += message.length;
+      msg = stack.slice(0, index);
+      // remove msg from stack
+      stack = stack.slice(index + 1);
+
+      if (err.cause) {
+        seen = seen || new Set();
+        seen.add(err);
+        const causeStack = getFullErrorStack(err.cause, seen);
+        stack += '\n   Caused by: ' + causeStack.msg + (causeStack.stack ? '\n' + causeStack.stack : '');
+      }
+    }
+
+    return {
+      message,
+      msg,
+      stack
+    };
+  };
+
   /**
    * Outputs the given `failures` as a list.
    *
@@ -15488,7 +15732,6 @@
         color('error stack', '\n%s\n');
 
       // msg
-      var msg;
       var err;
       if (test.err && test.err.multiple) {
         if (multipleTest !== test) {
@@ -15499,25 +15742,8 @@
       } else {
         err = test.err;
       }
-      var message;
-      if (typeof err.inspect === 'function') {
-        message = err.inspect() + '';
-      } else if (err.message && typeof err.message.toString === 'function') {
-        message = err.message + '';
-      } else {
-        message = '';
-      }
-      var stack = err.stack || message;
-      var index = message ? stack.indexOf(message) : -1;
 
-      if (index === -1) {
-        msg = message;
-      } else {
-        index += message.length;
-        msg = stack.slice(0, index);
-        // remove msg from stack
-        stack = stack.slice(index + 1);
-      }
+      var { message, msg, stack } = getFullErrorStack(err);
 
       // uncaught
       if (err.uncaught) {
@@ -15795,6 +16021,15 @@
   Base.consoleLog = consoleLog;
 
   Base.abstract = true;
+
+  /**
+   * An object with all stack traces recursively mounted from each err.cause
+   * @memberof module:lib/reporters/base
+   * @typedef {Object} FullErrorStack
+   * @property {string} message
+   * @property {string} msg
+   * @property {string} stack
+   */
   }(base$1, base$1.exports));
 
   var dot = {exports: {}};
@@ -16455,143 +16690,6 @@
 
   var html = {exports: {}};
 
-  /**
-   @module browser/Progress
-  */
-
-  /**
-   * Expose `Progress`.
-   */
-
-  var progress$1 = Progress;
-
-  /**
-   * Initialize a new `Progress` indicator.
-   */
-  function Progress() {
-    this.percent = 0;
-    this.size(0);
-    this.fontSize(11);
-    this.font('helvetica, arial, sans-serif');
-  }
-
-  /**
-   * Set progress size to `size`.
-   *
-   * @public
-   * @param {number} size
-   * @return {Progress} Progress instance.
-   */
-  Progress.prototype.size = function (size) {
-    this._size = size;
-    return this;
-  };
-
-  /**
-   * Set text to `text`.
-   *
-   * @public
-   * @param {string} text
-   * @return {Progress} Progress instance.
-   */
-  Progress.prototype.text = function (text) {
-    this._text = text;
-    return this;
-  };
-
-  /**
-   * Set font size to `size`.
-   *
-   * @public
-   * @param {number} size
-   * @return {Progress} Progress instance.
-   */
-  Progress.prototype.fontSize = function (size) {
-    this._fontSize = size;
-    return this;
-  };
-
-  /**
-   * Set font to `family`.
-   *
-   * @param {string} family
-   * @return {Progress} Progress instance.
-   */
-  Progress.prototype.font = function (family) {
-    this._font = family;
-    return this;
-  };
-
-  /**
-   * Update percentage to `n`.
-   *
-   * @param {number} n
-   * @return {Progress} Progress instance.
-   */
-  Progress.prototype.update = function (n) {
-    this.percent = n;
-    return this;
-  };
-
-  /**
-   * Draw on `ctx`.
-   *
-   * @param {CanvasRenderingContext2d} ctx
-   * @return {Progress} Progress instance.
-   */
-  Progress.prototype.draw = function (ctx) {
-    try {
-      var darkMatcher = window.matchMedia('(prefers-color-scheme: dark)');
-      var isDarkMode = !!darkMatcher.matches;
-      var lightColors = {
-        outerCircle: '#9f9f9f',
-        innerCircle: '#eee',
-        text: '#000'
-      };
-      var darkColors = {
-        outerCircle: '#888',
-        innerCircle: '#444',
-        text: '#fff'
-      };
-      var colors = isDarkMode ? darkColors : lightColors;
-
-      var percent = Math.min(this.percent, 100);
-      var size = this._size;
-      var half = size / 2;
-      var x = half;
-      var y = half;
-      var rad = half - 1;
-      var fontSize = this._fontSize;
-
-      ctx.font = fontSize + 'px ' + this._font;
-
-      var angle = Math.PI * 2 * (percent / 100);
-      ctx.clearRect(0, 0, size, size);
-
-      // outer circle
-      ctx.strokeStyle = colors.outerCircle;
-      ctx.beginPath();
-      ctx.arc(x, y, rad, 0, angle, false);
-      ctx.stroke();
-
-      // inner circle
-      ctx.strokeStyle = colors.innerCircle;
-      ctx.beginPath();
-      ctx.arc(x, y, rad - 1, 0, angle, true);
-      ctx.stroke();
-
-      // text
-      var text = this._text || (percent | 0) + '%';
-      var w = ctx.measureText(text).width;
-
-      ctx.fillStyle = colors.text;
-      ctx.fillText(text, x - w / 2 + 1, y + fontSize / 2 - 1);
-    } catch (ignore) {
-      // don't fail if we can't render progress
-    }
-    return this;
-  };
-
   (function (module, exports) {
 
   /* eslint-env browser */
@@ -16604,7 +16702,6 @@
 
   var Base = base$1.exports;
   var utils = utils$3;
-  var Progress = progress$1;
   var escapeRe = escapeStringRegexp;
   var constants = runner.constants;
   var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
@@ -16632,7 +16729,7 @@
 
   var statsTemplate =
     '<ul id="mocha-stats">' +
-    '<li class="progress"><canvas width="40" height="40"></canvas></li>' +
+    '<li class="progress-contain"><progress class="progress-element" max="100" value="0"></progress><svg class="progress-ring"><circle class="ring-flatlight" stroke-dasharray="100%,0%"/><circle class="ring-highlight" stroke-dasharray="0%,100%"/></svg><div class="progress-text">0%</div></li>' +
     '<li class="passes"><a href="javascript:void(0);">passes:</a> <em>0</em></li>' +
     '<li class="failures"><a href="javascript:void(0);">failures:</a> <em>0</em></li>' +
     '<li class="duration">duration: <em>0</em>s</li>' +
@@ -16662,24 +16759,15 @@
     var failures = items[2].getElementsByTagName('em')[0];
     var failuresLink = items[2].getElementsByTagName('a')[0];
     var duration = items[3].getElementsByTagName('em')[0];
-    var canvas = stat.getElementsByTagName('canvas')[0];
     var report = fragment('<ul id="mocha-report"></ul>');
     var stack = [report];
-    var progress;
-    var ctx;
+    var progressText = items[0].getElementsByTagName('div')[0];
+    var progressBar = items[0].getElementsByTagName('progress')[0];
+    var progressRing = [
+      items[0].getElementsByClassName('ring-flatlight')[0],
+      items[0].getElementsByClassName('ring-highlight')[0]];
     var root = document.getElementById('mocha');
 
-    if (canvas.getContext) {
-      var ratio = window.devicePixelRatio || 1;
-      canvas.style.width = canvas.width;
-      canvas.style.height = canvas.height;
-      canvas.width *= ratio;
-      canvas.height *= ratio;
-      ctx = canvas.getContext('2d');
-      ctx.scale(ratio, ratio);
-      progress = new Progress();
-    }
-
     if (!root) {
       return error('#mocha div missing, add it to your document');
     }
@@ -16709,10 +16797,6 @@
     root.appendChild(stat);
     root.appendChild(report);
 
-    if (progress) {
-      progress.size(40);
-    }
-
     runner.on(EVENT_SUITE_BEGIN, function (suite) {
       if (suite.root) {
         return;
@@ -16828,8 +16912,26 @@
     function updateStats() {
       // TODO: add to stats
       var percent = ((stats.tests / runner.total) * 100) | 0;
-      if (progress) {
-        progress.update(percent).draw(ctx);
+      progressBar.value = percent;
+      if (progressText) {
+        // setting a toFixed that is too low, makes small changes to progress not shown
+        // setting it too high, makes the progress text longer then it needs to
+        // to address this, calculate the toFixed based on the magnitude of total
+        var decimalPlaces = Math.ceil(Math.log10(runner.total / 100));
+        text(
+          progressText,
+          percent.toFixed(Math.min(Math.max(decimalPlaces, 0), 100)) + '%'
+        );
+      }
+      if (progressRing) {
+        var radius = parseFloat(getComputedStyle(progressRing[0]).getPropertyValue('r'));
+        var wholeArc = Math.PI * 2 * radius;
+        var highlightArc = percent * (wholeArc / 100);
+        // The progress ring is in 2 parts, the flatlight color and highlight color.
+        // Rendering both on top of the other, seems to make a 3rd color on the edges.
+        // To create 1 whole ring with 2 colors, both parts are inverse of the other.
+        progressRing[0].style['stroke-dasharray'] = `0,${highlightArc}px,${wholeArc}px`;
+        progressRing[1].style['stroke-dasharray'] = `${highlightArc}px,${wholeArc}px`;
       }
 
       // update stats
@@ -17658,6 +17760,7 @@
     var attrs = {
       classname: test.parent.fullTitle(),
       name: test.title,
+      file: test.file,
       time: test.duration / 1000 || 0
     };
 
@@ -19066,7 +19169,7 @@
   };
 
   var name = "mocha";
-  var version = "10.3.0";
+  var version = "10.6.0";
   var homepage = "https://mochajs.org/";
   var notifyLogo = "https://ibin.co/4QuRuGjXvl36.png";
   var require$$17 = {
@@ -20465,8 +20568,8 @@
 
   process.on = function (e, fn) {
     if (e === 'uncaughtException') {
-      commonjsGlobal.onerror = function (err, url, line) {
-        fn(new Error(err + ' (' + url + ':' + line + ')'));
+      commonjsGlobal.onerror = function (msg, url, line, col, err) {
+        fn(err || new Error(msg + ' (' + url + ':' + line + ':' + col + ')'));
         return !mocha.options.allowUncaught;
       };
       uncaughtExceptionHandlers.push(fn);