mocha 11.3.0 → 11.5.0

package/mocha.js

@@ -1,4 +1,4 @@
-// mocha@11.3.0 in javascript ES2018
+// mocha@11.5.0 in javascript ES2018
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
@@ -5810,56 +5810,47 @@
     value: true
   });
   exports["default"] = Diff;
-
   /*istanbul ignore end*/
   function Diff() {}
-
   Diff.prototype = {
     /*istanbul ignore start*/
-
     /*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] : {};
       var callback = options.callback;
-
       if (typeof options === 'function') {
         callback = options;
         options = {};
       }
-
-      this.options = options;
       var self = this;
-
       function done(value) {
+        value = self.postProcess(value, options);
         if (callback) {
           setTimeout(function () {
-            callback(undefined, value);
+            callback(value);
           }, 0);
           return true;
         } else {
           return value;
         }
-      } // Allow subclasses to massage the input prior to running
-
+      }
 
-      oldString = this.castInput(oldString);
-      newString = this.castInput(newString);
-      oldString = this.removeEmpty(this.tokenize(oldString));
-      newString = this.removeEmpty(this.tokenize(newString));
+      // Allow subclasses to massage the input prior to running
+      oldString = this.castInput(oldString, options);
+      newString = this.castInput(newString, options);
+      oldString = this.removeEmpty(this.tokenize(oldString, options));
+      newString = this.removeEmpty(this.tokenize(newString, options));
       var newLen = newString.length,
-          oldLen = oldString.length;
+        oldLen = oldString.length;
       var editLength = 1;
       var maxEditLength = newLen + oldLen;
-
-      if (options.maxEditLength) {
+      if (options.maxEditLength != null) {
         maxEditLength = Math.min(maxEditLength, options.maxEditLength);
       }
-
       var maxExecutionTime =
       /*istanbul ignore start*/
       (_options$timeout =
@@ -5869,17 +5860,16 @@
       var bestPath = [{
         oldPos: -1,
         lastComponent: undefined
-      }]; // Seed editLength = 0, i.e. the content starts with the same values
-
-      var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+      }];
 
+      // Seed editLength = 0, i.e. the content starts with the same values
+      var newPos = this.extractCommon(bestPath[0], newString, oldString, 0, options);
       if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
         // Identity per the equality and tokenizer
-        return done([{
-          value: this.join(newString),
-          count: newString.length
-        }]);
-      } // Once we hit the right edge of the edit graph on some diagonal k, we can
+        return done(buildValues(self, bestPath[0].lastComponent, newString, oldString, self.useLongestToken));
+      }
+
+      // 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).
@@ -5896,11 +5886,10 @@
       // 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.
+        maxDiagonalToConsider = Infinity;
 
+      // Main worker method. checks all permutations of a given edit length for acceptance.
       function execEditLength() {
         for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
           var basePath =
@@ -5909,72 +5898,59 @@
           /*istanbul ignore end*/
           ;
           var removePath = bestPath[diagonalPath - 1],
-              addPath = bestPath[diagonalPath + 1];
-
+            addPath = bestPath[diagonalPath + 1];
           if (removePath) {
             // No one else is going to attempt to use this value, clear it
             bestPath[diagonalPath - 1] = undefined;
           }
-
           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
+          }
+
+          // Select the diagonal that we want to branch from. We select the prior
           // 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 (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {
-            basePath = self.addToPath(addPath, true, undefined, 0);
+          if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+            basePath = self.addToPath(addPath, true, false, 0, options);
           } else {
-            basePath = self.addToPath(removePath, undefined, true, 1);
+            basePath = self.addToPath(removePath, false, true, 1, options);
           }
-
-          newPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
-
+          newPos = self.extractCommon(basePath, newString, oldString, diagonalPath, options);
           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 {
             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
+      }
+
+      // 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, or until the edit length exceeds options.maxEditLength (if given),
       // in which case it will return undefined.
-
-
       if (callback) {
         (function exec() {
           setTimeout(function () {
             if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
               return callback();
             }
-
             if (!execEditLength()) {
               exec();
             }
@@ -5983,21 +5959,17 @@
       } else {
         while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
           var ret = execEditLength();
-
           if (ret) {
             return ret;
           }
         }
       }
     },
-
     /*istanbul ignore start*/
-
     /*istanbul ignore end*/
-    addToPath: function addToPath(path, added, removed, oldPosInc) {
+    addToPath: function addToPath(path, added, removed, oldPosInc, options) {
       var last = path.lastComponent;
-
-      if (last && last.added === added && last.removed === removed) {
+      if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
         return {
           oldPos: path.oldPos + oldPosInc,
           lastComponent: {
@@ -6019,104 +5991,97 @@
         };
       }
     },
-
     /*istanbul ignore start*/
-
     /*istanbul ignore end*/
-    extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
+    extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath, options) {
       var newLen = newString.length,
-          oldLen = oldString.length,
-          oldPos = basePath.oldPos,
-          newPos = oldPos - diagonalPath,
-          commonCount = 0;
-
-      while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+        oldLen = oldString.length,
+        oldPos = basePath.oldPos,
+        newPos = oldPos - diagonalPath,
+        commonCount = 0;
+      while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldString[oldPos + 1], newString[newPos + 1], options)) {
         newPos++;
         oldPos++;
         commonCount++;
+        if (options.oneChangePerToken) {
+          basePath.lastComponent = {
+            count: 1,
+            previousComponent: basePath.lastComponent,
+            added: false,
+            removed: false
+          };
+        }
       }
-
-      if (commonCount) {
+      if (commonCount && !options.oneChangePerToken) {
         basePath.lastComponent = {
           count: commonCount,
-          previousComponent: basePath.lastComponent
+          previousComponent: basePath.lastComponent,
+          added: false,
+          removed: false
         };
       }
-
       basePath.oldPos = oldPos;
       return newPos;
     },
-
     /*istanbul ignore start*/
-
     /*istanbul ignore end*/
-    equals: function equals(left, right) {
-      if (this.options.comparator) {
-        return this.options.comparator(left, right);
+    equals: function equals(left, right, options) {
+      if (options.comparator) {
+        return options.comparator(left, right);
       } else {
-        return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+        return left === right || options.ignoreCase && left.toLowerCase() === right.toLowerCase();
       }
     },
-
     /*istanbul ignore start*/
-
     /*istanbul ignore end*/
     removeEmpty: function removeEmpty(array) {
       var ret = [];
-
       for (var i = 0; i < array.length; i++) {
         if (array[i]) {
           ret.push(array[i]);
         }
       }
-
       return ret;
     },
-
     /*istanbul ignore start*/
-
     /*istanbul ignore end*/
     castInput: function castInput(value) {
       return value;
     },
-
     /*istanbul ignore start*/
-
     /*istanbul ignore end*/
     tokenize: function tokenize(value) {
-      return value.split('');
+      return Array.from(value);
     },
-
     /*istanbul ignore start*/
-
     /*istanbul ignore end*/
     join: function join(chars) {
       return chars.join('');
+    },
+    /*istanbul ignore start*/
+    /*istanbul ignore end*/
+    postProcess: function postProcess(changeObjects) {
+      return changeObjects;
     }
   };
-
   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,
-        oldPos = 0;
-
+      componentLen = components.length,
+      newPos = 0,
+      oldPos = 0;
     for (; componentPos < componentLen; componentPos++) {
       var component = components[componentPos];
-
       if (!component.removed) {
         if (!component.added && useLongestToken) {
           var value = newString.slice(newPos, newPos + component.count);
@@ -6128,36 +6093,17 @@
         } else {
           component.value = diff.join(newString.slice(newPos, newPos + component.count));
         }
+        newPos += component.count;
 
-        newPos += component.count; // Common case
-
+        // Common case
         if (!component.added) {
           oldPos += component.count;
         }
       } else {
         component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
-        oldPos += component.count; // Reverse add and remove so removes are output first to match common convention
-        // The diffing algorithm is tied to add then remove output and this is the simplest
-        // route to get the desired output with minimal overhead.
-
-        if (componentPos && components[componentPos - 1].added) {
-          var tmp = components[componentPos - 1];
-          components[componentPos - 1] = components[componentPos];
-          components[componentPos] = tmp;
-        }
+        oldPos += component.count;
       }
-    } // Special case handle for when one terminal is ignored (i.e. whitespace).
-    // For this case we merge the terminal into the prior string and drop the change.
-    // This is only available for string mode.
-
-
-    var finalComponent = components[componentLen - 1];
-
-    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;
   }
 
@@ -6170,20 +6116,21 @@
   Object.defineProperty(character, "__esModule", {
     value: true
   });
-  character.diffChars = diffChars;
   character.characterDiff = void 0;
-
+  character.diffChars = diffChars;
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _base$6 = _interopRequireDefault$7(base)
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault$7(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
   /*istanbul ignore end*/
-  var characterDiff = new
+  var characterDiff =
+  /*istanbul ignore start*/
+  character.characterDiff =
+  /*istanbul ignore end*/
+  new
   /*istanbul ignore start*/
   _base$6
   /*istanbul ignore end*/
@@ -6192,40 +6139,142 @@
   "default"
   /*istanbul ignore end*/
   ]();
-
-  /*istanbul ignore start*/
-  character.characterDiff = characterDiff;
-
-  /*istanbul ignore end*/
   function diffChars(oldStr, newStr, options) {
     return characterDiff.diff(oldStr, newStr, options);
   }
 
   var word = {};
 
-  var params = {};
+  var string = {};
 
   /*istanbul ignore start*/
 
-  Object.defineProperty(params, "__esModule", {
+  Object.defineProperty(string, "__esModule", {
     value: true
   });
-  params.generateOptions = generateOptions;
-
+  string.hasOnlyUnixLineEndings = hasOnlyUnixLineEndings;
+  string.hasOnlyWinLineEndings = hasOnlyWinLineEndings;
+  string.longestCommonPrefix = longestCommonPrefix;
+  string.longestCommonSuffix = longestCommonSuffix;
+  string.maximumOverlap = maximumOverlap;
+  string.removePrefix = removePrefix;
+  string.removeSuffix = removeSuffix;
+  string.replacePrefix = replacePrefix;
+  string.replaceSuffix = replaceSuffix;
   /*istanbul ignore end*/
-  function generateOptions(options, defaults) {
-    if (typeof options === 'function') {
-      defaults.callback = options;
-    } else if (options) {
-      for (var name in options) {
-        /* istanbul ignore else */
-        if (options.hasOwnProperty(name)) {
-          defaults[name] = options[name];
-        }
+  function longestCommonPrefix(str1, str2) {
+    var i;
+    for (i = 0; i < str1.length && i < str2.length; i++) {
+      if (str1[i] != str2[i]) {
+        return str1.slice(0, i);
       }
     }
+    return str1.slice(0, i);
+  }
+  function longestCommonSuffix(str1, str2) {
+    var i;
 
-    return defaults;
+    // Unlike longestCommonPrefix, we need a special case to handle all scenarios
+    // where we return the empty string since str1.slice(-0) will return the
+    // entire string.
+    if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+      return '';
+    }
+    for (i = 0; i < str1.length && i < str2.length; i++) {
+      if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+        return str1.slice(-i);
+      }
+    }
+    return str1.slice(-i);
+  }
+  function replacePrefix(string, oldPrefix, newPrefix) {
+    if (string.slice(0, oldPrefix.length) != oldPrefix) {
+      throw Error(
+      /*istanbul ignore start*/
+      "string ".concat(
+      /*istanbul ignore end*/
+      JSON.stringify(string), " doesn't start with prefix ").concat(JSON.stringify(oldPrefix), "; this is a bug"));
+    }
+    return newPrefix + string.slice(oldPrefix.length);
+  }
+  function replaceSuffix(string, oldSuffix, newSuffix) {
+    if (!oldSuffix) {
+      return string + newSuffix;
+    }
+    if (string.slice(-oldSuffix.length) != oldSuffix) {
+      throw Error(
+      /*istanbul ignore start*/
+      "string ".concat(
+      /*istanbul ignore end*/
+      JSON.stringify(string), " doesn't end with suffix ").concat(JSON.stringify(oldSuffix), "; this is a bug"));
+    }
+    return string.slice(0, -oldSuffix.length) + newSuffix;
+  }
+  function removePrefix(string, oldPrefix) {
+    return replacePrefix(string, oldPrefix, '');
+  }
+  function removeSuffix(string, oldSuffix) {
+    return replaceSuffix(string, oldSuffix, '');
+  }
+  function maximumOverlap(string1, string2) {
+    return string2.slice(0, overlapCount(string1, string2));
+  }
+
+  // Nicked from https://stackoverflow.com/a/60422853/1709587
+  function overlapCount(a, b) {
+    // Deal with cases where the strings differ in length
+    var startA = 0;
+    if (a.length > b.length) {
+      startA = a.length - b.length;
+    }
+    var endB = b.length;
+    if (a.length < b.length) {
+      endB = a.length;
+    }
+    // Create a back-reference for each index
+    //   that should be followed in case of a mismatch.
+    //   We only need B to make these references:
+    var map = Array(endB);
+    var k = 0; // Index that lags behind j
+    map[0] = 0;
+    for (var j = 1; j < endB; j++) {
+      if (b[j] == b[k]) {
+        map[j] = map[k]; // skip over the same character (optional optimisation)
+      } else {
+        map[j] = k;
+      }
+      while (k > 0 && b[j] != b[k]) {
+        k = map[k];
+      }
+      if (b[j] == b[k]) {
+        k++;
+      }
+    }
+    // Phase 2: use these references while iterating over A
+    k = 0;
+    for (var i = startA; i < a.length; i++) {
+      while (k > 0 && a[i] != b[k]) {
+        k = map[k];
+      }
+      if (a[i] == b[k]) {
+        k++;
+      }
+    }
+    return k;
+  }
+
+  /**
+   * Returns true if the string consistently uses Windows line endings.
+   */
+  function hasOnlyWinLineEndings(string) {
+    return string.includes('\r\n') && !string.startsWith('\n') && !string.match(/[^\r]\n/);
+  }
+
+  /**
+   * Returns true if the string consistently uses Unix line endings.
+   */
+  function hasOnlyUnixLineEndings(string) {
+    return !string.includes('\r\n') && string.includes('\n');
   }
 
   /*istanbul ignore start*/
@@ -6235,23 +6284,19 @@
   });
   word.diffWords = diffWords;
   word.diffWordsWithSpace = diffWordsWithSpace;
-  word.wordDiff = void 0;
-
+  word.wordWithSpaceDiff = word.wordDiff = void 0;
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _base$5 = _interopRequireDefault$6(base)
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
-  _params$1 = params
+  _string$1 = string
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault$6(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
   /*istanbul ignore end*/
   // Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode
   //
@@ -6271,9 +6316,43 @@
   //  - U+02DC  ˜ &#732;  Small Tilde
   //  - U+02DD  ˝ &#733;  Double Acute Accent
   // Latin Extended Additional, 1E00–1EFF
-  var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
-  var reWhitespace = /\S/;
-  var wordDiff = new
+  var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+
+  // Each token is one of the following:
+  // - A punctuation mark plus the surrounding whitespace
+  // - A word plus the surrounding whitespace
+  // - Pure whitespace (but only in the special case where this the entire text
+  //   is just whitespace)
+  //
+  // We have to include surrounding whitespace in the tokens because the two
+  // alternative approaches produce horribly broken results:
+  // * If we just discard the whitespace, we can't fully reproduce the original
+  //   text from the sequence of tokens and any attempt to render the diff will
+  //   get the whitespace wrong.
+  // * If we have separate tokens for whitespace, then in a typical text every
+  //   second token will be a single space character. But this often results in
+  //   the optimal diff between two texts being a perverse one that preserves
+  //   the spaces between words but deletes and reinserts actual common words.
+  //   See https://github.com/kpdecker/jsdiff/issues/160#issuecomment-1866099640
+  //   for an example.
+  //
+  // Keeping the surrounding whitespace of course has implications for .equals
+  // and .join, not just .tokenize.
+
+  // This regex does NOT fully implement the tokenization rules described above.
+  // Instead, it gives runs of whitespace their own "token". The tokenize method
+  // then handles stitching whitespace tokens onto adjacent word or punctuation
+  // tokens.
+  var tokenizeIncludingWhitespace = new RegExp(
+  /*istanbul ignore start*/
+  "[".concat(
+  /*istanbul ignore end*/
+  extendedWordChars, "]+|\\s+|[^").concat(extendedWordChars, "]"), 'ug');
+  var wordDiff =
+  /*istanbul ignore start*/
+  word.wordDiff =
+  /*istanbul ignore end*/
+  new
   /*istanbul ignore start*/
   _base$5
   /*istanbul ignore end*/
@@ -6282,139 +6361,576 @@
   "default"
   /*istanbul ignore end*/
   ]();
-
-  /*istanbul ignore start*/
-  word.wordDiff = wordDiff;
-
-  /*istanbul ignore end*/
-  wordDiff.equals = function (left, right) {
-    if (this.options.ignoreCase) {
+  wordDiff.equals = function (left, right, options) {
+    if (options.ignoreCase) {
       left = left.toLowerCase();
       right = right.toLowerCase();
     }
-
-    return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
+    return left.trim() === right.trim();
   };
-
   wordDiff.tokenize = function (value) {
-    // All whitespace symbols except newline group into one token, each newline - in separate token
-    var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/); // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set.
-
-    for (var i = 0; i < tokens.length - 1; i++) {
-      // If we have an empty string in the next field and we have only word chars before and after, merge
-      if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
-        tokens[i] += tokens[i + 2];
-        tokens.splice(i + 1, 2);
-        i--;
-      }
-    }
-
-    return tokens;
-  };
-
-  function diffWords(oldStr, newStr, options) {
-    options =
-    /*istanbul ignore start*/
-    (/*istanbul ignore end*/
-
-    /*istanbul ignore start*/
-    0, _params$1
-    /*istanbul ignore end*/
-    .
     /*istanbul ignore start*/
-    generateOptions)
+    var
     /*istanbul ignore end*/
-    (options, {
-      ignoreWhitespace: true
+    options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var parts;
+    if (options.intlSegmenter) {
+      if (options.intlSegmenter.resolvedOptions().granularity != 'word') {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      parts = Array.from(options.intlSegmenter.segment(value), function (segment)
+      /*istanbul ignore start*/
+      {
+        return (
+          /*istanbul ignore end*/
+          segment.segment
+        );
+      });
+    } else {
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    }
+    var tokens = [];
+    var prevPart = null;
+    parts.forEach(function (part) {
+      if (/\s/.test(part)) {
+        if (prevPart == null) {
+          tokens.push(part);
+        } else {
+          tokens.push(tokens.pop() + part);
+        }
+      } else if (/\s/.test(prevPart)) {
+        if (tokens[tokens.length - 1] == prevPart) {
+          tokens.push(tokens.pop() + part);
+        } else {
+          tokens.push(prevPart + part);
+        }
+      } else {
+        tokens.push(part);
+      }
+      prevPart = part;
     });
-    return wordDiff.diff(oldStr, newStr, options);
-  }
-
-  function diffWordsWithSpace(oldStr, newStr, options) {
-    return wordDiff.diff(oldStr, newStr, options);
-  }
-
-  var line = {};
-
-  /*istanbul ignore start*/
-
-  Object.defineProperty(line, "__esModule", {
-    value: true
-  });
-  line.diffLines = diffLines;
-  line.diffTrimmedLines = diffTrimmedLines;
-  line.lineDiff = void 0;
-
-  /*istanbul ignore end*/
-  var
-  /*istanbul ignore start*/
-  _base$4 = _interopRequireDefault$5(base)
-  /*istanbul ignore end*/
-  ;
-
-  var
-  /*istanbul ignore start*/
-  _params = params
-  /*istanbul ignore end*/
-  ;
-
-  /*istanbul ignore start*/ function _interopRequireDefault$5(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-  /*istanbul ignore end*/
-  var lineDiff = new
-  /*istanbul ignore start*/
-  _base$4
-  /*istanbul ignore end*/
-  [
-  /*istanbul ignore start*/
-  "default"
-  /*istanbul ignore end*/
-  ]();
-
-  /*istanbul ignore start*/
-  line.lineDiff = lineDiff;
-
-  /*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');
+    return tokens;
+  };
+  wordDiff.join = function (tokens) {
+    // Tokens being joined here will always have appeared consecutively in the
+    // same text, so we can simply strip off the leading whitespace from all the
+    // tokens except the first (and except any whitespace-only tokens - but such
+    // a token will always be the first and only token anyway) and then join them
+    // and the whitespace around words and punctuation will end up correct.
+    return tokens.map(function (token, i) {
+      if (i == 0) {
+        return token;
+      } else {
+        return token.replace(/^\s+/, '');
+      }
+    }).join('');
+  };
+  wordDiff.postProcess = function (changes, options) {
+    if (!changes || options.oneChangePerToken) {
+      return changes;
     }
-
-    var retLines = [],
-        linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line
-
-    if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-      linesAndNewlines.pop();
-    } // Merge the content and line separators into single tokens
-
-
-    for (var i = 0; i < linesAndNewlines.length; i++) {
-      var line = linesAndNewlines[i];
-
-      if (i % 2 && !this.options.newlineIsToken) {
-        retLines[retLines.length - 1] += line;
+    var lastKeep = null;
+    // Change objects representing any insertion or deletion since the last
+    // "keep" change object. There can be at most one of each.
+    var insertion = null;
+    var deletion = null;
+    changes.forEach(function (change) {
+      if (change.added) {
+        insertion = change;
+      } else if (change.removed) {
+        deletion = change;
       } else {
-        if (this.options.ignoreWhitespace) {
-          line = line.trim();
+        if (insertion || deletion) {
+          // May be false at start of text
+          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
         }
-
-        retLines.push(line);
+        lastKeep = change;
+        insertion = null;
+        deletion = null;
       }
+    });
+    if (insertion || deletion) {
+      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
     }
-
-    return retLines;
+    return changes;
+  };
+  function diffWords(oldStr, newStr, options) {
+    // This option has never been documented and never will be (it's clearer to
+    // just call `diffWordsWithSpace` directly if you need that behavior), but
+    // has existed in jsdiff for a long time, so we retain support for it here
+    // for the sake of backwards compatibility.
+    if (
+    /*istanbul ignore start*/
+    (
+    /*istanbul ignore end*/
+    options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
+      return diffWordsWithSpace(oldStr, newStr, options);
+    }
+    return wordDiff.diff(oldStr, newStr, options);
+  }
+  function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
+    // Before returning, we tidy up the leading and trailing whitespace of the
+    // change objects to eliminate cases where trailing whitespace in one object
+    // is repeated as leading whitespace in the next.
+    // Below are examples of the outcomes we want here to explain the code.
+    // I=insert, K=keep, D=delete
+    // 1. diffing 'foo bar baz' vs 'foo baz'
+    //    Prior to cleanup, we have K:'foo ' D:' bar ' K:' baz'
+    //    After cleanup, we want:   K:'foo ' D:'bar ' K:'baz'
+    //
+    // 2. Diffing 'foo bar baz' vs 'foo qux baz'
+    //    Prior to cleanup, we have K:'foo ' D:' bar ' I:' qux ' K:' baz'
+    //    After cleanup, we want K:'foo ' D:'bar' I:'qux' K:' baz'
+    //
+    // 3. Diffing 'foo\nbar baz' vs 'foo baz'
+    //    Prior to cleanup, we have K:'foo ' D:'\nbar ' K:' baz'
+    //    After cleanup, we want K'foo' D:'\nbar' K:' baz'
+    //
+    // 4. Diffing 'foo baz' vs 'foo\nbar baz'
+    //    Prior to cleanup, we have K:'foo\n' I:'\nbar ' K:' baz'
+    //    After cleanup, we ideally want K'foo' I:'\nbar' K:' baz'
+    //    but don't actually manage this currently (the pre-cleanup change
+    //    objects don't contain enough information to make it possible).
+    //
+    // 5. Diffing 'foo   bar baz' vs 'foo  baz'
+    //    Prior to cleanup, we have K:'foo  ' D:'   bar ' K:'  baz'
+    //    After cleanup, we want K:'foo  ' D:' bar ' K:'baz'
+    //
+    // Our handling is unavoidably imperfect in the case where there's a single
+    // indel between keeps and the whitespace has changed. For instance, consider
+    // diffing 'foo\tbar\nbaz' vs 'foo baz'. Unless we create an extra change
+    // object to represent the insertion of the space character (which isn't even
+    // a token), we have no way to avoid losing information about the texts'
+    // original whitespace in the result we return. Still, we do our best to
+    // output something that will look sensible if we e.g. print it with
+    // insertions in green and deletions in red.
+
+    // Between two "keep" change objects (or before the first or after the last
+    // change object), we can have either:
+    // * A "delete" followed by an "insert"
+    // * Just an "insert"
+    // * Just a "delete"
+    // We handle the three cases separately.
+    if (deletion && insertion) {
+      var oldWsPrefix = deletion.value.match(/^\s*/)[0];
+      var oldWsSuffix = deletion.value.match(/\s*$/)[0];
+      var newWsPrefix = insertion.value.match(/^\s*/)[0];
+      var newWsSuffix = insertion.value.match(/\s*$/)[0];
+      if (startKeep) {
+        var commonWsPrefix =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        longestCommonPrefix)
+        /*istanbul ignore end*/
+        (oldWsPrefix, newWsPrefix);
+        startKeep.value =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        replaceSuffix)
+        /*istanbul ignore end*/
+        (startKeep.value, newWsPrefix, commonWsPrefix);
+        deletion.value =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        removePrefix)
+        /*istanbul ignore end*/
+        (deletion.value, commonWsPrefix);
+        insertion.value =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        removePrefix)
+        /*istanbul ignore end*/
+        (insertion.value, commonWsPrefix);
+      }
+      if (endKeep) {
+        var commonWsSuffix =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        longestCommonSuffix)
+        /*istanbul ignore end*/
+        (oldWsSuffix, newWsSuffix);
+        endKeep.value =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        replacePrefix)
+        /*istanbul ignore end*/
+        (endKeep.value, newWsSuffix, commonWsSuffix);
+        deletion.value =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        removeSuffix)
+        /*istanbul ignore end*/
+        (deletion.value, commonWsSuffix);
+        insertion.value =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _string$1
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        removeSuffix)
+        /*istanbul ignore end*/
+        (insertion.value, commonWsSuffix);
+      }
+    } else if (insertion) {
+      // The whitespaces all reflect what was in the new text rather than
+      // the old, so we essentially have no information about whitespace
+      // insertion or deletion. We just want to dedupe the whitespace.
+      // We do that by having each change object keep its trailing
+      // whitespace and deleting duplicate leading whitespace where
+      // present.
+      if (startKeep) {
+        insertion.value = insertion.value.replace(/^\s*/, '');
+      }
+      if (endKeep) {
+        endKeep.value = endKeep.value.replace(/^\s*/, '');
+      }
+      // otherwise we've got a deletion and no insertion
+    } else if (startKeep && endKeep) {
+      var newWsFull = endKeep.value.match(/^\s*/)[0],
+        delWsStart = deletion.value.match(/^\s*/)[0],
+        delWsEnd = deletion.value.match(/\s*$/)[0];
+
+      // Any whitespace that comes straight after startKeep in both the old and
+      // new texts, assign to startKeep and remove from the deletion.
+      var newWsStart =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      longestCommonPrefix)
+      /*istanbul ignore end*/
+      (newWsFull, delWsStart);
+      deletion.value =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      removePrefix)
+      /*istanbul ignore end*/
+      (deletion.value, newWsStart);
+
+      // Any whitespace that comes straight before endKeep in both the old and
+      // new texts, and hasn't already been assigned to startKeep, assign to
+      // endKeep and remove from the deletion.
+      var newWsEnd =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      longestCommonSuffix)
+      /*istanbul ignore end*/
+      (
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      removePrefix)
+      /*istanbul ignore end*/
+      (newWsFull, newWsStart), delWsEnd);
+      deletion.value =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      removeSuffix)
+      /*istanbul ignore end*/
+      (deletion.value, newWsEnd);
+      endKeep.value =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      replacePrefix)
+      /*istanbul ignore end*/
+      (endKeep.value, newWsFull, newWsEnd);
+
+      // If there's any whitespace from the new text that HASN'T already been
+      // assigned, assign it to the start:
+      startKeep.value =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      replaceSuffix)
+      /*istanbul ignore end*/
+      (startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+    } else if (endKeep) {
+      // We are at the start of the text. Preserve all the whitespace on
+      // endKeep, and just remove whitespace from the end of deletion to the
+      // extent that it overlaps with the start of endKeep.
+      var endKeepWsPrefix = endKeep.value.match(/^\s*/)[0];
+      var deletionWsSuffix = deletion.value.match(/\s*$/)[0];
+      var overlap =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      maximumOverlap)
+      /*istanbul ignore end*/
+      (deletionWsSuffix, endKeepWsPrefix);
+      deletion.value =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      removeSuffix)
+      /*istanbul ignore end*/
+      (deletion.value, overlap);
+    } else if (startKeep) {
+      // We are at the END of the text. Preserve all the whitespace on
+      // startKeep, and just remove whitespace from the start of deletion to
+      // the extent that it overlaps with the end of startKeep.
+      var startKeepWsSuffix = startKeep.value.match(/\s*$/)[0];
+      var deletionWsPrefix = deletion.value.match(/^\s*/)[0];
+      var _overlap =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      maximumOverlap)
+      /*istanbul ignore end*/
+      (startKeepWsSuffix, deletionWsPrefix);
+      deletion.value =
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string$1
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      removePrefix)
+      /*istanbul ignore end*/
+      (deletion.value, _overlap);
+    }
+  }
+  var wordWithSpaceDiff =
+  /*istanbul ignore start*/
+  word.wordWithSpaceDiff =
+  /*istanbul ignore end*/
+  new
+  /*istanbul ignore start*/
+  _base$5
+  /*istanbul ignore end*/
+  [
+  /*istanbul ignore start*/
+  "default"
+  /*istanbul ignore end*/
+  ]();
+  wordWithSpaceDiff.tokenize = function (value) {
+    // Slightly different to the tokenizeIncludingWhitespace regex used above in
+    // that this one treats each individual newline as a distinct tokens, rather
+    // than merging them into other surrounding whitespace. This was requested
+    // in https://github.com/kpdecker/jsdiff/issues/180 &
+    //    https://github.com/kpdecker/jsdiff/issues/211
+    var regex = new RegExp(
+    /*istanbul ignore start*/
+    "(\\r?\\n)|[".concat(
+    /*istanbul ignore end*/
+    extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), 'ug');
+    return value.match(regex) || [];
   };
+  function diffWordsWithSpace(oldStr, newStr, options) {
+    return wordWithSpaceDiff.diff(oldStr, newStr, options);
+  }
+
+  var line = {};
 
+  var params = {};
+
+  /*istanbul ignore start*/
+
+  Object.defineProperty(params, "__esModule", {
+    value: true
+  });
+  params.generateOptions = generateOptions;
+  /*istanbul ignore end*/
+  function generateOptions(options, defaults) {
+    if (typeof options === 'function') {
+      defaults.callback = options;
+    } else if (options) {
+      for (var name in options) {
+        /* istanbul ignore else */
+        if (options.hasOwnProperty(name)) {
+          defaults[name] = options[name];
+        }
+      }
+    }
+    return defaults;
+  }
+
+  /*istanbul ignore start*/
+
+  Object.defineProperty(line, "__esModule", {
+    value: true
+  });
+  line.diffLines = diffLines;
+  line.diffTrimmedLines = diffTrimmedLines;
+  line.lineDiff = void 0;
+  /*istanbul ignore end*/
+  var
+  /*istanbul ignore start*/
+  _base$4 = _interopRequireDefault$5(base)
+  /*istanbul ignore end*/
+  ;
+  var
+  /*istanbul ignore start*/
+  _params = params
+  /*istanbul ignore end*/
+  ;
+  /*istanbul ignore start*/ function _interopRequireDefault$5(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+  /*istanbul ignore end*/
+  var lineDiff =
+  /*istanbul ignore start*/
+  line.lineDiff =
+  /*istanbul ignore end*/
+  new
+  /*istanbul ignore start*/
+  _base$4
+  /*istanbul ignore end*/
+  [
+  /*istanbul ignore start*/
+  "default"
+  /*istanbul ignore end*/
+  ]();
+  lineDiff.tokenize = function (value, options) {
+    if (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
+    if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+      linesAndNewlines.pop();
+    }
+
+    // Merge the content and line separators into single tokens
+    for (var i = 0; i < linesAndNewlines.length; i++) {
+      var line = linesAndNewlines[i];
+      if (i % 2 && !options.newlineIsToken) {
+        retLines[retLines.length - 1] += line;
+      } else {
+        retLines.push(line);
+      }
+    }
+    return retLines;
+  };
+  lineDiff.equals = function (left, right, options) {
+    // If we're ignoring whitespace, we need to normalise lines by stripping
+    // whitespace before checking equality. (This has an annoying interaction
+    // with newlineIsToken that requires special handling: if newlines get their
+    // own token, then we DON'T want to trim the *newline* tokens down to empty
+    // strings, since this would cause us to treat whitespace-only line content
+    // as equal to a separator between lines, which would be weird and
+    // inconsistent with the documented behavior of the options.)
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes('\n')) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes('\n')) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith('\n')) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith('\n')) {
+        right = right.slice(0, -1);
+      }
+    }
+    return (
+      /*istanbul ignore start*/
+      _base$4
+      /*istanbul ignore end*/
+      [
+      /*istanbul ignore start*/
+      "default"
+      /*istanbul ignore end*/
+      ].prototype.equals.call(this, left, right, options)
+    );
+  };
   function diffLines(oldStr, newStr, callback) {
     return lineDiff.diff(oldStr, newStr, callback);
   }
 
+  // Kept for backwards compatibility. This is a rather arbitrary wrapper method
+  // that just calls `diffLines` with `ignoreWhitespace: true`. It's confusing to
+  // have two ways to do exactly the same thing in the API, so we no longer
+  // document this one (library users should explicitly use `diffLines` with
+  // `ignoreWhitespace: true` instead) but we keep it around to maintain
+  // compatibility with code that used old versions.
   function diffTrimmedLines(oldStr, newStr, callback) {
     var options =
     /*istanbul ignore start*/
     (/*istanbul ignore end*/
-
     /*istanbul ignore start*/
     0, _params
     /*istanbul ignore end*/
@@ -6437,18 +6953,19 @@
   });
   sentence.diffSentences = diffSentences;
   sentence.sentenceDiff = void 0;
-
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _base$3 = _interopRequireDefault$4(base)
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault$4(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
   /*istanbul ignore end*/
-  var sentenceDiff = new
+  var sentenceDiff =
+  /*istanbul ignore start*/
+  sentence.sentenceDiff =
+  /*istanbul ignore end*/
+  new
   /*istanbul ignore start*/
   _base$3
   /*istanbul ignore end*/
@@ -6457,15 +6974,9 @@
   "default"
   /*istanbul ignore end*/
   ]();
-
-  /*istanbul ignore start*/
-  sentence.sentenceDiff = sentenceDiff;
-
-  /*istanbul ignore end*/
   sentenceDiff.tokenize = function (value) {
     return value.split(/(\S.+?[.!?])(?=\s+|$)/);
   };
-
   function diffSentences(oldStr, newStr, callback) {
     return sentenceDiff.diff(oldStr, newStr, callback);
   }
@@ -6477,20 +6988,21 @@
   Object.defineProperty(css, "__esModule", {
     value: true
   });
-  css.diffCss = diffCss;
   css.cssDiff = void 0;
-
+  css.diffCss = diffCss;
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _base$2 = _interopRequireDefault$3(base)
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault$3(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
   /*istanbul ignore end*/
-  var cssDiff = new
+  var cssDiff =
+  /*istanbul ignore start*/
+  css.cssDiff =
+  /*istanbul ignore end*/
+  new
   /*istanbul ignore start*/
   _base$2
   /*istanbul ignore end*/
@@ -6499,15 +7011,9 @@
   "default"
   /*istanbul ignore end*/
   ]();
-
-  /*istanbul ignore start*/
-  css.cssDiff = cssDiff;
-
-  /*istanbul ignore end*/
   cssDiff.tokenize = function (value) {
     return value.split(/([{}:;,]|\s+)/);
   };
-
   function diffCss(oldStr, newStr, callback) {
     return cssDiff.diff(oldStr, newStr, callback);
   }
@@ -6519,30 +7025,28 @@
   Object.defineProperty(json$1, "__esModule", {
     value: true
   });
-  json$1.diffJson = diffJson;
   json$1.canonicalize = canonicalize;
+  json$1.diffJson = diffJson;
   json$1.jsonDiff = void 0;
-
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _base$1 = _interopRequireDefault$2(base)
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _line$1 = line
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-  function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
+  function _typeof$3(o) { "@babel/helpers - typeof"; return _typeof$3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$3(o); }
   /*istanbul ignore end*/
-  var objectPrototypeToString = Object.prototype.toString;
-  var jsonDiff = new
+  var jsonDiff =
+  /*istanbul ignore start*/
+  json$1.jsonDiff =
+  /*istanbul ignore end*/
+  new
   /*istanbul ignore start*/
   _base$1
   /*istanbul ignore end*/
@@ -6550,13 +7054,9 @@
   /*istanbul ignore start*/
   "default"
   /*istanbul ignore end*/
-  ](); // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
+  ]();
+  // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
   // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
-
-  /*istanbul ignore start*/
-  json$1.jsonDiff = jsonDiff;
-
-  /*istanbul ignore end*/
   jsonDiff.useLongestToken = true;
   jsonDiff.tokenize =
   /*istanbul ignore start*/
@@ -6567,26 +7067,28 @@
   lineDiff
   /*istanbul ignore end*/
   .tokenize;
-
-  jsonDiff.castInput = function (value) {
-    /*istanbul ignore start*/
-    var _this$options =
-    /*istanbul ignore end*/
-    this.options,
-        undefinedReplacement = _this$options.undefinedReplacement,
-        _this$options$stringi = _this$options.stringifyReplacer,
-        stringifyReplacer = _this$options$stringi === void 0 ? function (k, v)
-    /*istanbul ignore start*/
-    {
-      return (
-        /*istanbul ignore end*/
-        typeof v === 'undefined' ? undefinedReplacement : v
-      );
-    } : _this$options$stringi;
+  jsonDiff.castInput = function (value, options) {
+    var
+      /*istanbul ignore start*/
+      /*istanbul ignore end*/
+      undefinedReplacement = options.undefinedReplacement,
+      /*istanbul ignore start*/
+      _options$stringifyRep =
+      /*istanbul ignore end*/
+      options.stringifyReplacer,
+      /*istanbul ignore start*/
+      /*istanbul ignore end*/
+      stringifyReplacer = _options$stringifyRep === void 0 ? function (k, v)
+      /*istanbul ignore start*/
+      {
+        return (
+          /*istanbul ignore end*/
+          typeof v === 'undefined' ? undefinedReplacement : v
+        );
+      } : _options$stringifyRep;
     return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, '  ');
   };
-
-  jsonDiff.equals = function (left, right) {
+  jsonDiff.equals = function (left, right, options) {
     return (
       /*istanbul ignore start*/
       _base$1
@@ -6595,84 +7097,68 @@
       /*istanbul ignore start*/
       "default"
       /*istanbul ignore end*/
-      ].prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'))
+      ].prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options)
     );
   };
-
   function diffJson(oldObj, newObj, options) {
     return jsonDiff.diff(oldObj, newObj, options);
-  } // This function handles the presence of circular references by bailing out when encountering an
-  // object that is already on the "stack" of items being processed. Accepts an optional replacer
-
+  }
 
+  // This function handles the presence of circular references by bailing out when encountering an
+  // object that is already on the "stack" of items being processed. Accepts an optional replacer
   function canonicalize(obj, stack, replacementStack, replacer, key) {
     stack = stack || [];
     replacementStack = replacementStack || [];
-
     if (replacer) {
       obj = replacer(key, obj);
     }
-
     var i;
-
     for (i = 0; i < stack.length; i += 1) {
       if (stack[i] === obj) {
         return replacementStack[i];
       }
     }
-
     var canonicalizedObj;
-
-    if ('[object Array]' === objectPrototypeToString.call(obj)) {
+    if ('[object Array]' === Object.prototype.toString.call(obj)) {
       stack.push(obj);
       canonicalizedObj = new Array(obj.length);
       replacementStack.push(canonicalizedObj);
-
       for (i = 0; i < obj.length; i += 1) {
         canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
       }
-
       stack.pop();
       replacementStack.pop();
       return canonicalizedObj;
     }
-
     if (obj && obj.toJSON) {
       obj = obj.toJSON();
     }
-
     if (
     /*istanbul ignore start*/
-    _typeof(
+    _typeof$3(
     /*istanbul ignore end*/
     obj) === 'object' && obj !== null) {
       stack.push(obj);
       canonicalizedObj = {};
       replacementStack.push(canonicalizedObj);
-
       var sortedKeys = [],
-          _key;
-
+        _key;
       for (_key in obj) {
         /* istanbul ignore else */
-        if (obj.hasOwnProperty(_key)) {
+        if (Object.prototype.hasOwnProperty.call(obj, _key)) {
           sortedKeys.push(_key);
         }
       }
-
       sortedKeys.sort();
-
       for (i = 0; i < sortedKeys.length; i += 1) {
         _key = sortedKeys[i];
         canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
       }
-
       stack.pop();
       replacementStack.pop();
     } else {
       canonicalizedObj = obj;
     }
-
     return canonicalizedObj;
   }
 
@@ -6683,20 +7169,21 @@
   Object.defineProperty(array$1, "__esModule", {
     value: true
   });
-  array$1.diffArrays = diffArrays;
   array$1.arrayDiff = void 0;
-
+  array$1.diffArrays = diffArrays;
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _base = _interopRequireDefault$1(base)
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
   /*istanbul ignore end*/
-  var arrayDiff = new
+  var arrayDiff =
+  /*istanbul ignore start*/
+  array$1.arrayDiff =
+  /*istanbul ignore end*/
+  new
   /*istanbul ignore start*/
   _base
   /*istanbul ignore end*/
@@ -6705,25 +7192,195 @@
   "default"
   /*istanbul ignore end*/
   ]();
-
-  /*istanbul ignore start*/
-  array$1.arrayDiff = arrayDiff;
-
-  /*istanbul ignore end*/
   arrayDiff.tokenize = function (value) {
     return value.slice();
   };
-
   arrayDiff.join = arrayDiff.removeEmpty = function (value) {
     return value;
   };
-
   function diffArrays(oldArr, newArr, callback) {
     return arrayDiff.diff(oldArr, newArr, callback);
   }
 
   var apply = {};
 
+  var lineEndings = {};
+
+  /*istanbul ignore start*/
+
+  Object.defineProperty(lineEndings, "__esModule", {
+    value: true
+  });
+  lineEndings.isUnix = isUnix;
+  lineEndings.isWin = isWin;
+  lineEndings.unixToWin = unixToWin;
+  lineEndings.winToUnix = winToUnix;
+  function _typeof$2(o) { "@babel/helpers - typeof"; return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$2(o); }
+  function ownKeys$2(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+  function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), !0).forEach(function (r) { _defineProperty$2(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+  function _defineProperty$2(obj, key, value) { key = _toPropertyKey$2(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  function _toPropertyKey$2(t) { var i = _toPrimitive$2(t, "string"); return "symbol" == _typeof$2(i) ? i : i + ""; }
+  function _toPrimitive$2(t, r) { if ("object" != _typeof$2(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof$2(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+  /*istanbul ignore end*/
+  function unixToWin(patch) {
+    if (Array.isArray(patch)) {
+      return patch.map(unixToWin);
+    }
+    return (
+      /*istanbul ignore start*/
+      _objectSpread$2(_objectSpread$2({},
+      /*istanbul ignore end*/
+      patch), {}, {
+        hunks: patch.hunks.map(function (hunk)
+        /*istanbul ignore start*/
+        {
+          return _objectSpread$2(_objectSpread$2({},
+          /*istanbul ignore end*/
+          hunk), {}, {
+            lines: hunk.lines.map(function (line, i)
+            /*istanbul ignore start*/
+            {
+              var _hunk$lines;
+              return (
+                /*istanbul ignore end*/
+                line.startsWith('\\') || line.endsWith('\r') ||
+                /*istanbul ignore start*/
+                (_hunk$lines =
+                /*istanbul ignore end*/
+                hunk.lines[i + 1]) !== null && _hunk$lines !== void 0 &&
+                /*istanbul ignore start*/
+                _hunk$lines
+                /*istanbul ignore end*/
+                .startsWith('\\') ? line : line + '\r'
+              );
+            })
+          });
+        })
+      })
+    );
+  }
+  function winToUnix(patch) {
+    if (Array.isArray(patch)) {
+      return patch.map(winToUnix);
+    }
+    return (
+      /*istanbul ignore start*/
+      _objectSpread$2(_objectSpread$2({},
+      /*istanbul ignore end*/
+      patch), {}, {
+        hunks: patch.hunks.map(function (hunk)
+        /*istanbul ignore start*/
+        {
+          return _objectSpread$2(_objectSpread$2({},
+          /*istanbul ignore end*/
+          hunk), {}, {
+            lines: hunk.lines.map(function (line)
+            /*istanbul ignore start*/
+            {
+              return (
+                /*istanbul ignore end*/
+                line.endsWith('\r') ? line.substring(0, line.length - 1) : line
+              );
+            })
+          });
+        })
+      })
+    );
+  }
+
+  /**
+   * Returns true if the patch consistently uses Unix line endings (or only involves one line and has
+   * no line endings).
+   */
+  function isUnix(patch) {
+    if (!Array.isArray(patch)) {
+      patch = [patch];
+    }
+    return !patch.some(function (index)
+    /*istanbul ignore start*/
+    {
+      return (
+        /*istanbul ignore end*/
+        index.hunks.some(function (hunk)
+        /*istanbul ignore start*/
+        {
+          return (
+            /*istanbul ignore end*/
+            hunk.lines.some(function (line)
+            /*istanbul ignore start*/
+            {
+              return (
+                /*istanbul ignore end*/
+                !line.startsWith('\\') && line.endsWith('\r')
+              );
+            })
+          );
+        })
+      );
+    });
+  }
+
+  /**
+   * Returns true if the patch uses Windows line endings and only Windows line endings.
+   */
+  function isWin(patch) {
+    if (!Array.isArray(patch)) {
+      patch = [patch];
+    }
+    return patch.some(function (index)
+    /*istanbul ignore start*/
+    {
+      return (
+        /*istanbul ignore end*/
+        index.hunks.some(function (hunk)
+        /*istanbul ignore start*/
+        {
+          return (
+            /*istanbul ignore end*/
+            hunk.lines.some(function (line)
+            /*istanbul ignore start*/
+            {
+              return (
+                /*istanbul ignore end*/
+                line.endsWith('\r')
+              );
+            })
+          );
+        })
+      );
+    }) && patch.every(function (index)
+    /*istanbul ignore start*/
+    {
+      return (
+        /*istanbul ignore end*/
+        index.hunks.every(function (hunk)
+        /*istanbul ignore start*/
+        {
+          return (
+            /*istanbul ignore end*/
+            hunk.lines.every(function (line, i)
+            /*istanbul ignore start*/
+            {
+              var _hunk$lines2;
+              return (
+                /*istanbul ignore end*/
+                line.startsWith('\\') || line.endsWith('\r') ||
+                /*istanbul ignore start*/
+                ((_hunk$lines2 =
+                /*istanbul ignore end*/
+                hunk.lines[i + 1]) === null || _hunk$lines2 === void 0 ? void 0 :
+                /*istanbul ignore start*/
+                _hunk$lines2
+                /*istanbul ignore end*/
+                .startsWith('\\'))
+              );
+            })
+          );
+        })
+      );
+    });
+  }
+
   var parse$2 = {};
 
   /*istanbul ignore start*/
@@ -6732,123 +7389,110 @@
     value: true
   });
   parse$2.parsePatch = parsePatch;
-
   /*istanbul ignore end*/
   function parsePatch(uniDiff) {
-    /*istanbul ignore start*/
-    var
-    /*istanbul ignore end*/
-    options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/),
-        delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [],
-        list = [],
-        i = 0;
-
+    var diffstr = uniDiff.split(/\n/),
+      list = [],
+      i = 0;
     function parseIndex() {
       var index = {};
-      list.push(index); // Parse diff metadata
+      list.push(index);
 
+      // Parse diff metadata
       while (i < diffstr.length) {
-        var line = diffstr[i]; // File header found, end parsing diff metadata
+        var line = diffstr[i];
 
+        // File header found, end parsing diff metadata
         if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
           break;
-        } // Diff index
-
+        }
 
+        // Diff index
         var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
-
         if (header) {
           index.index = header[1];
         }
-
         i++;
-      } // Parse file headers if they are defined. Unified diff requires them, but
-      // there's no technical issues to have an isolated hunk without file header
-
+      }
 
+      // Parse file headers if they are defined. Unified diff requires them, but
+      // there's no technical issues to have an isolated hunk without file header
+      parseFileHeader(index);
       parseFileHeader(index);
-      parseFileHeader(index); // Parse hunks
 
+      // Parse hunks
       index.hunks = [];
-
       while (i < diffstr.length) {
         var _line = diffstr[i];
-
-        if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) {
+        if (/^(Index:\s|diff\s|\-\-\-\s|\+\+\+\s|===================================================================)/.test(_line)) {
           break;
         } else if (/^@@/.test(_line)) {
           index.hunks.push(parseHunk());
-        } else if (_line && options.strict) {
-          // Ignore unexpected content unless in strict mode
+        } else if (_line) {
           throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line));
         } else {
           i++;
         }
       }
-    } // Parses the --- and +++ headers, if none are found, no lines
-    // are consumed.
-
+    }
 
+    // Parses the --- and +++ headers, if none are found, no lines
+    // are consumed.
     function parseFileHeader(index) {
-      var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]);
-
+      var fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
       if (fileHeader) {
         var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';
         var data = fileHeader[2].split('\t', 2);
         var fileName = data[0].replace(/\\\\/g, '\\');
-
         if (/^".*"$/.test(fileName)) {
           fileName = fileName.substr(1, fileName.length - 2);
         }
-
         index[keyPrefix + 'FileName'] = fileName;
         index[keyPrefix + 'Header'] = (data[1] || '').trim();
         i++;
       }
-    } // Parses a hunk
-    // This assumes that we are at the start of a hunk.
-
+    }
 
+    // Parses a hunk
+    // This assumes that we are at the start of a hunk.
     function parseHunk() {
       var chunkHeaderIndex = i,
-          chunkHeaderLine = diffstr[i++],
-          chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        chunkHeaderLine = diffstr[i++],
+        chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
       var hunk = {
         oldStart: +chunkHeader[1],
         oldLines: typeof chunkHeader[2] === 'undefined' ? 1 : +chunkHeader[2],
         newStart: +chunkHeader[3],
         newLines: typeof chunkHeader[4] === 'undefined' ? 1 : +chunkHeader[4],
-        lines: [],
-        linedelimiters: []
-      }; // Unified Diff Format quirk: If the chunk size is 0,
+        lines: []
+      };
+
+      // Unified Diff Format quirk: If the chunk size is 0,
       // the first number is one lower than one would expect.
       // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
-
       if (hunk.oldLines === 0) {
         hunk.oldStart += 1;
       }
-
       if (hunk.newLines === 0) {
         hunk.newStart += 1;
       }
-
       var addCount = 0,
-          removeCount = 0;
-
-      for (; i < diffstr.length; i++) {
-        // Lines starting with '---' could be mistaken for the "remove line" operation
-        // But they could be the header for the next file. Therefore prune such cases out.
-        if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) {
-          break;
-        }
-
+        removeCount = 0;
+      for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines ||
+      /*istanbul ignore start*/
+      (_diffstr$i =
+      /*istanbul ignore end*/
+      diffstr[i]) !== null && _diffstr$i !== void 0 &&
+      /*istanbul ignore start*/
+      _diffstr$i
+      /*istanbul ignore end*/
+      .startsWith('\\')); i++) {
+        /*istanbul ignore start*/
+        var _diffstr$i;
+        /*istanbul ignore end*/
         var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0];
-
         if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') {
           hunk.lines.push(diffstr[i]);
-          hunk.linedelimiters.push(delimiters[i] || '\n');
-
           if (operation === '+') {
             addCount++;
           } else if (operation === '-') {
@@ -6858,37 +7502,34 @@
             removeCount++;
           }
         } else {
-          break;
+          throw new Error(
+          /*istanbul ignore start*/
+          "Hunk at line ".concat(
+          /*istanbul ignore end*/
+          chunkHeaderIndex + 1, " contained invalid line ").concat(diffstr[i]));
         }
-      } // Handle the empty block count case
-
+      }
 
+      // Handle the empty block count case
       if (!addCount && hunk.newLines === 1) {
         hunk.newLines = 0;
       }
-
       if (!removeCount && hunk.oldLines === 1) {
         hunk.oldLines = 0;
-      } // Perform optional sanity checking
-
-
-      if (options.strict) {
-        if (addCount !== hunk.newLines) {
-          throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
-        }
-
-        if (removeCount !== hunk.oldLines) {
-          throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
-        }
       }
 
+      // Perform sanity checking
+      if (addCount !== hunk.newLines) {
+        throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+      }
+      if (removeCount !== hunk.oldLines) {
+        throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+      }
       return hunk;
     }
-
     while (i < diffstr.length) {
       parseIndex();
     }
-
     return list;
   }
 
@@ -6902,7 +7543,6 @@
     value: true
   });
   exports["default"] = _default;
-
   /*istanbul ignore end*/
   // Iterator that traverses in the range of [min, max], stepping
   // by distance from a given start position. I.e. for [0, 4], with
@@ -6913,42 +7553,40 @@
   /*istanbul ignore end*/
   (start, minLine, maxLine) {
     var wantForward = true,
-        backwardExhausted = false,
-        forwardExhausted = false,
-        localOffset = 1;
+      backwardExhausted = false,
+      forwardExhausted = false,
+      localOffset = 1;
     return function iterator() {
       if (wantForward && !forwardExhausted) {
         if (backwardExhausted) {
           localOffset++;
         } else {
           wantForward = false;
-        } // Check if trying to fit beyond text length, and if not, check it fits
-        // after offset location (or desired location on first iteration)
-
+        }
 
+        // Check if trying to fit beyond text length, and if not, check it fits
+        // after offset location (or desired location on first iteration)
         if (start + localOffset <= maxLine) {
-          return localOffset;
+          return start + localOffset;
         }
-
         forwardExhausted = true;
       }
-
       if (!backwardExhausted) {
         if (!forwardExhausted) {
           wantForward = true;
-        } // Check if trying to fit before text beginning, and if not, check it fits
-        // before offset location
-
+        }
 
+        // Check if trying to fit before text beginning, and if not, check it fits
+        // before offset location
         if (minLine <= start - localOffset) {
-          return -localOffset++;
+          return start - localOffset++;
         }
-
         backwardExhausted = true;
         return iterator();
-      } // We tried to fit hunk before text beginning and beyond text length, then
-      // hunk can't fit on the text. Return undefined
+      }
 
+      // We tried to fit hunk before text beginning and beyond text length, then
+      // hunk can't fit on the text. Return undefined
     };
   }
 
@@ -6961,34 +7599,38 @@
   });
   apply.applyPatch = applyPatch;
   apply.applyPatches = applyPatches;
-
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
+  _string = string
+  /*istanbul ignore end*/
+  ;
+  var
+  /*istanbul ignore start*/
+  _lineEndings = lineEndings
+  /*istanbul ignore end*/
+  ;
+  var
+  /*istanbul ignore start*/
   _parse$1 = parse$2
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _distanceIterator = _interopRequireDefault(distanceIterator)
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
   /*istanbul ignore end*/
   function applyPatch(source, uniDiff) {
     /*istanbul ignore start*/
     var
     /*istanbul ignore end*/
     options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
     if (typeof uniDiff === 'string') {
       uniDiff =
       /*istanbul ignore start*/
       (/*istanbul ignore end*/
-
       /*istanbul ignore start*/
       0, _parse$1
       /*istanbul ignore end*/
@@ -6998,158 +7640,310 @@
       /*istanbul ignore end*/
       (uniDiff);
     }
-
     if (Array.isArray(uniDiff)) {
       if (uniDiff.length > 1) {
         throw new Error('applyPatch only works with a single input.');
       }
-
       uniDiff = uniDiff[0];
-    } // Apply the diff to the input
+    }
+    if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
+      if (
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      hasOnlyWinLineEndings)
+      /*istanbul ignore end*/
+      (source) &&
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _lineEndings
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      isUnix)
+      /*istanbul ignore end*/
+      (uniDiff)) {
+        uniDiff =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _lineEndings
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        unixToWin)
+        /*istanbul ignore end*/
+        (uniDiff);
+      } else if (
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _string
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      hasOnlyUnixLineEndings)
+      /*istanbul ignore end*/
+      (source) &&
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _lineEndings
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      isWin)
+      /*istanbul ignore end*/
+      (uniDiff)) {
+        uniDiff =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _lineEndings
+        /*istanbul ignore end*/
+        .
+        /*istanbul ignore start*/
+        winToUnix)
+        /*istanbul ignore end*/
+        (uniDiff);
+      }
+    }
 
+    // Apply the diff to the input
+    var lines = source.split('\n'),
+      hunks = uniDiff.hunks,
+      compareLine = options.compareLine || function (lineNumber, line, operation, patchContent)
+      /*istanbul ignore start*/
+      {
+        return (
+          /*istanbul ignore end*/
+          line === patchContent
+        );
+      },
+      fuzzFactor = options.fuzzFactor || 0,
+      minLine = 0;
+    if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
+      throw new Error('fuzzFactor must be a non-negative integer');
+    }
+
+    // Special case for empty patch.
+    if (!hunks.length) {
+      return source;
+    }
+
+    // Before anything else, handle EOFNL insertion/removal. If the patch tells us to make a change
+    // to the EOFNL that is redundant/impossible - i.e. to remove a newline that's not there, or add a
+    // newline that already exists - then we either return false and fail to apply the patch (if
+    // fuzzFactor is 0) or simply ignore the problem and do nothing (if fuzzFactor is >0).
+    // If we do need to remove/add a newline at EOF, this will always be in the final hunk:
+    var prevLine = '',
+      removeEOFNL = false,
+      addEOFNL = false;
+    for (var i = 0; i < hunks[hunks.length - 1].lines.length; i++) {
+      var line = hunks[hunks.length - 1].lines[i];
+      if (line[0] == '\\') {
+        if (prevLine[0] == '+') {
+          removeEOFNL = true;
+        } else if (prevLine[0] == '-') {
+          addEOFNL = true;
+        }
+      }
+      prevLine = line;
+    }
+    if (removeEOFNL) {
+      if (addEOFNL) {
+        // This means the final line gets changed but doesn't have a trailing newline in either the
+        // original or patched version. In that case, we do nothing if fuzzFactor > 0, and if
+        // fuzzFactor is 0, we simply validate that the source file has no trailing newline.
+        if (!fuzzFactor && lines[lines.length - 1] == '') {
+          return false;
+        }
+      } else if (lines[lines.length - 1] == '') {
+        lines.pop();
+      } else if (!fuzzFactor) {
+        return false;
+      }
+    } else if (addEOFNL) {
+      if (lines[lines.length - 1] != '') {
+        lines.push('');
+      } else if (!fuzzFactor) {
+        return false;
+      }
+    }
 
-    var lines = source.split(/\r\n|[\n\v\f\r\x85]/),
-        delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [],
-        hunks = uniDiff.hunks,
-        compareLine = options.compareLine || function (lineNumber, line, operation, patchContent)
-    /*istanbul ignore start*/
-    {
-      return (
-        /*istanbul ignore end*/
-        line === patchContent
-      );
-    },
-        errorCount = 0,
-        fuzzFactor = options.fuzzFactor || 0,
-        minLine = 0,
-        offset = 0,
-        removeEOFNL,
-        addEOFNL;
     /**
-     * Checks if the hunk exactly fits on the provided location
+     * Checks if the hunk can be made to fit at the provided location with at most `maxErrors`
+     * insertions, substitutions, or deletions, while ensuring also that:
+     * - lines deleted in the hunk match exactly, and
+     * - wherever an insertion operation or block of insertion operations appears in the hunk, the
+     *   immediately preceding and following lines of context match exactly
+     *
+     * `toPos` should be set such that lines[toPos] is meant to match hunkLines[0].
+     *
+     * If the hunk can be applied, returns an object with properties `oldLineLastI` and
+     * `replacementLines`. Otherwise, returns null.
      */
-
-
-    function hunkFits(hunk, toPos) {
-      for (var j = 0; j < hunk.lines.length; j++) {
-        var line = hunk.lines[j],
-            operation = line.length > 0 ? line[0] : ' ',
-            content = line.length > 0 ? line.substr(1) : line;
-
-        if (operation === ' ' || operation === '-') {
-          // Context sanity check
-          if (!compareLine(toPos + 1, lines[toPos], operation, content)) {
-            errorCount++;
-
-            if (errorCount > fuzzFactor) {
-              return false;
+    function applyHunk(hunkLines, toPos, maxErrors) {
+      /*istanbul ignore start*/
+      var
+      /*istanbul ignore end*/
+      hunkLinesI = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+      /*istanbul ignore start*/
+      var
+      /*istanbul ignore end*/
+      lastContextLineMatched = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+      /*istanbul ignore start*/
+      var
+      /*istanbul ignore end*/
+      patchedLines = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+      /*istanbul ignore start*/
+      var
+      /*istanbul ignore end*/
+      patchedLinesLength = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+      var nConsecutiveOldContextLines = 0;
+      var nextContextLineMustMatch = false;
+      for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
+        var hunkLine = hunkLines[hunkLinesI],
+          operation = hunkLine.length > 0 ? hunkLine[0] : ' ',
+          content = hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine;
+        if (operation === '-') {
+          if (compareLine(toPos + 1, lines[toPos], operation, content)) {
+            toPos++;
+            nConsecutiveOldContextLines = 0;
+          } else {
+            if (!maxErrors || lines[toPos] == null) {
+              return null;
             }
+            patchedLines[patchedLinesLength] = lines[toPos];
+            return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);
+          }
+        }
+        if (operation === '+') {
+          if (!lastContextLineMatched) {
+            return null;
           }
+          patchedLines[patchedLinesLength] = content;
+          patchedLinesLength++;
+          nConsecutiveOldContextLines = 0;
+          nextContextLineMustMatch = true;
+        }
+        if (operation === ' ') {
+          nConsecutiveOldContextLines++;
+          patchedLines[patchedLinesLength] = lines[toPos];
+          if (compareLine(toPos + 1, lines[toPos], operation, content)) {
+            patchedLinesLength++;
+            lastContextLineMatched = true;
+            nextContextLineMustMatch = false;
+            toPos++;
+          } else {
+            if (nextContextLineMustMatch || !maxErrors) {
+              return null;
+            }
 
-          toPos++;
+            // Consider 3 possibilities in sequence:
+            // 1. lines contains a *substitution* not included in the patch context, or
+            // 2. lines contains an *insertion* not included in the patch context, or
+            // 3. lines contains a *deletion* not included in the patch context
+            // The first two options are of course only possible if the line from lines is non-null -
+            // i.e. only option 3 is possible if we've overrun the end of the old file.
+            return lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength);
+          }
         }
       }
 
-      return true;
-    } // Search best fit offsets for each hunk based on the previous ones
-
-
-    for (var i = 0; i < hunks.length; i++) {
-      var hunk = hunks[i],
-          maxLine = lines.length - hunk.oldLines,
-          localOffset = 0,
-          toPos = offset + hunk.oldStart - 1;
-      var iterator =
-      /*istanbul ignore start*/
-      (/*istanbul ignore end*/
+      // Before returning, trim any unmodified context lines off the end of patchedLines and reduce
+      // toPos (and thus oldLineLastI) accordingly. This allows later hunks to be applied to a region
+      // that starts in this hunk's trailing context.
+      patchedLinesLength -= nConsecutiveOldContextLines;
+      toPos -= nConsecutiveOldContextLines;
+      patchedLines.length = patchedLinesLength;
+      return {
+        patchedLines: patchedLines,
+        oldLineLastI: toPos - 1
+      };
+    }
+    var resultLines = [];
 
+    // Search best fit offsets for each hunk based on the previous ones
+    var prevHunkOffset = 0;
+    for (var _i = 0; _i < hunks.length; _i++) {
+      var hunk = hunks[_i];
+      var hunkResult =
       /*istanbul ignore start*/
-      0, _distanceIterator
+      void 0
       /*istanbul ignore end*/
-      [
+      ;
+      var maxLine = lines.length - hunk.oldLines + fuzzFactor;
+      var toPos =
       /*istanbul ignore start*/
-      "default"
+      void 0
       /*istanbul ignore end*/
-      ])(toPos, minLine, maxLine);
-
-      for (; localOffset !== undefined; localOffset = iterator()) {
-        if (hunkFits(hunk, toPos + localOffset)) {
-          hunk.offset = offset += localOffset;
+      ;
+      for (var maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
+        toPos = hunk.oldStart + prevHunkOffset - 1;
+        var iterator =
+        /*istanbul ignore start*/
+        (/*istanbul ignore end*/
+        /*istanbul ignore start*/
+        0, _distanceIterator
+        /*istanbul ignore end*/
+        [
+        /*istanbul ignore start*/
+        "default"
+        /*istanbul ignore end*/
+        ])(toPos, minLine, maxLine);
+        for (; toPos !== undefined; toPos = iterator()) {
+          hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
+          if (hunkResult) {
+            break;
+          }
+        }
+        if (hunkResult) {
           break;
         }
       }
-
-      if (localOffset === undefined) {
+      if (!hunkResult) {
         return false;
-      } // Set lower text limit to end of the current hunk, so next ones don't try
-      // to fit over already patched text
-
-
-      minLine = hunk.offset + hunk.oldStart + hunk.oldLines;
-    } // Apply patch hunks
-
-
-    var diffOffset = 0;
-
-    for (var _i = 0; _i < hunks.length; _i++) {
-      var _hunk = hunks[_i],
-          _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1;
-
-      diffOffset += _hunk.newLines - _hunk.oldLines;
+      }
 
-      for (var j = 0; j < _hunk.lines.length; j++) {
-        var line = _hunk.lines[j],
-            operation = line.length > 0 ? line[0] : ' ',
-            content = line.length > 0 ? line.substr(1) : line,
-            delimiter = _hunk.linedelimiters && _hunk.linedelimiters[j] || '\n';
+      // Copy everything from the end of where we applied the last hunk to the start of this hunk
+      for (var _i2 = minLine; _i2 < toPos; _i2++) {
+        resultLines.push(lines[_i2]);
+      }
 
-        if (operation === ' ') {
-          _toPos++;
-        } else if (operation === '-') {
-          lines.splice(_toPos, 1);
-          delimiters.splice(_toPos, 1);
-          /* istanbul ignore else */
-        } else if (operation === '+') {
-          lines.splice(_toPos, 0, content);
-          delimiters.splice(_toPos, 0, delimiter);
-          _toPos++;
-        } else if (operation === '\\') {
-          var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null;
-
-          if (previousOperation === '+') {
-            removeEOFNL = true;
-          } else if (previousOperation === '-') {
-            addEOFNL = true;
-          }
-        }
+      // Add the lines produced by applying the hunk:
+      for (var _i3 = 0; _i3 < hunkResult.patchedLines.length; _i3++) {
+        var _line = hunkResult.patchedLines[_i3];
+        resultLines.push(_line);
       }
-    } // Handle EOFNL insertion/removal
 
+      // Set lower text limit to end of the current hunk, so next ones don't try
+      // to fit over already patched text
+      minLine = hunkResult.oldLineLastI + 1;
 
-    if (removeEOFNL) {
-      while (!lines[lines.length - 1]) {
-        lines.pop();
-        delimiters.pop();
-      }
-    } else if (addEOFNL) {
-      lines.push('');
-      delimiters.push('\n');
+      // Note the offset between where the patch said the hunk should've applied and where we
+      // applied it, so we can adjust future hunks accordingly:
+      prevHunkOffset = toPos + 1 - hunk.oldStart;
     }
 
-    for (var _k = 0; _k < lines.length - 1; _k++) {
-      lines[_k] = lines[_k] + delimiters[_k];
+    // Copy over the rest of the lines from the old text
+    for (var _i4 = minLine; _i4 < lines.length; _i4++) {
+      resultLines.push(lines[_i4]);
     }
+    return resultLines.join('\n');
+  }
 
-    return lines.join('');
-  } // Wrapper that supports multiple file patches via callbacks.
-
-
+  // Wrapper that supports multiple file patches via callbacks.
   function applyPatches(uniDiff, options) {
     if (typeof uniDiff === 'string') {
       uniDiff =
       /*istanbul ignore start*/
       (/*istanbul ignore end*/
-
       /*istanbul ignore start*/
       0, _parse$1
       /*istanbul ignore end*/
@@ -7159,32 +7953,25 @@
       /*istanbul ignore end*/
       (uniDiff);
     }
-
     var currentIndex = 0;
-
     function processIndex() {
       var index = uniDiff[currentIndex++];
-
       if (!index) {
         return options.complete();
       }
-
       options.loadFile(index, function (err, data) {
         if (err) {
           return options.complete(err);
         }
-
         var updatedContent = applyPatch(data, index, options);
         options.patched(index, updatedContent, function (err) {
           if (err) {
             return options.complete(err);
           }
-
           processIndex();
         });
       });
     }
-
     processIndex();
   }
 
@@ -7197,275 +7984,367 @@
   Object.defineProperty(create, "__esModule", {
     value: true
   });
-  create.structuredPatch = structuredPatch;
-  create.formatPatch = formatPatch;
-  create.createTwoFilesPatch = createTwoFilesPatch;
   create.createPatch = createPatch;
-
+  create.createTwoFilesPatch = createTwoFilesPatch;
+  create.formatPatch = formatPatch;
+  create.structuredPatch = structuredPatch;
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _line = line
   /*istanbul ignore end*/
   ;
-
-  /*istanbul ignore start*/ function _toConsumableArray$1(arr) { return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread$1(); }
-
+  /*istanbul ignore start*/ function _typeof$1(o) { "@babel/helpers - typeof"; return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$1(o); }
+  function _toConsumableArray$1(arr) { return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread$1(); }
   function _nonIterableSpread$1() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
   function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
-
-  function _iterableToArray$1(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
+  function _iterableToArray$1(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
   function _arrayWithoutHoles$1(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$1(arr); }
-
-  function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
+  function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+  function ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+  function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty$1(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+  function _defineProperty$1(obj, key, value) { key = _toPropertyKey$1(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  function _toPropertyKey$1(t) { var i = _toPrimitive$1(t, "string"); return "symbol" == _typeof$1(i) ? i : i + ""; }
+  function _toPrimitive$1(t, r) { if ("object" != _typeof$1(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof$1(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
   /*istanbul ignore end*/
   function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
     if (!options) {
       options = {};
     }
-
+    if (typeof options === 'function') {
+      options = {
+        callback: options
+      };
+    }
     if (typeof options.context === 'undefined') {
       options.context = 4;
     }
-
-    var diff =
-    /*istanbul ignore start*/
-    (/*istanbul ignore end*/
-
-    /*istanbul ignore start*/
-    0, _line
-    /*istanbul ignore end*/
-    .
-    /*istanbul ignore start*/
-    diffLines)
-    /*istanbul ignore end*/
-    (oldStr, newStr, options);
-
-    if (!diff) {
-      return;
-    }
-
-    diff.push({
-      value: '',
-      lines: []
-    }); // Append an empty value to make cleanup easier
-
-    function contextLines(lines) {
-      return lines.map(function (entry) {
-        return ' ' + entry;
-      });
+    if (options.newlineIsToken) {
+      throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');
     }
-
-    var hunks = [];
-    var oldRangeStart = 0,
-        newRangeStart = 0,
-        curRange = [],
-        oldLine = 1,
-        newLine = 1;
-
-    /*istanbul ignore start*/
-    var _loop = function _loop(
-    /*istanbul ignore end*/
-    i) {
-      var current = diff[i],
-          lines = current.lines || current.value.replace(/\n$/, '').split('\n');
-      current.lines = lines;
-
-      if (current.added || current.removed) {
-        /*istanbul ignore start*/
-        var _curRange;
-
-        /*istanbul ignore end*/
-        // If we have previous context, start with that
-        if (!oldRangeStart) {
-          var prev = diff[i - 1];
-          oldRangeStart = oldLine;
-          newRangeStart = newLine;
-
-          if (prev) {
-            curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
-            oldRangeStart -= curRange.length;
-            newRangeStart -= curRange.length;
-          }
-        } // Output our changes
-
-
-        /*istanbul ignore start*/
-
-        /*istanbul ignore end*/
-
+    if (!options.callback) {
+      return diffLinesResultToPatch(
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _line
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      diffLines)
+      /*istanbul ignore end*/
+      (oldStr, newStr, options));
+    } else {
+      var
         /*istanbul ignore start*/
-        (_curRange =
+        _options =
         /*istanbul ignore end*/
-        curRange).push.apply(
+        options,
         /*istanbul ignore start*/
-        _curRange
         /*istanbul ignore end*/
-        ,
+        _callback = _options.callback;
+      /*istanbul ignore start*/
+      (/*istanbul ignore end*/
+      /*istanbul ignore start*/
+      0, _line
+      /*istanbul ignore end*/
+      .
+      /*istanbul ignore start*/
+      diffLines)
+      /*istanbul ignore end*/
+      (oldStr, newStr,
+      /*istanbul ignore start*/
+      _objectSpread$1(_objectSpread$1({},
+      /*istanbul ignore end*/
+      options), {}, {
+        callback: function
         /*istanbul ignore start*/
-        _toConsumableArray$1(
+        callback
         /*istanbul ignore end*/
-        lines.map(function (entry) {
-          return (current.added ? '+' : '-') + entry;
-        }))); // Track the updated file position
-
-
-        if (current.added) {
-          newLine += lines.length;
-        } else {
-          oldLine += lines.length;
+        (diff) {
+          var patch = diffLinesResultToPatch(diff);
+          _callback(patch);
         }
-      } else {
-        // Identical context lines. Track line changes
-        if (oldRangeStart) {
-          // Close out any changes that have been output (or join overlapping)
-          if (lines.length <= options.context * 2 && i < diff.length - 2) {
-            /*istanbul ignore start*/
-            var _curRange2;
+      }));
+    }
+    function diffLinesResultToPatch(diff) {
+      // STEP 1: Build up the patch with no "" lines and with the arrays
+      //         of lines containing trailing newline characters. We'll tidy up later...
 
-            /*istanbul ignore end*/
-            // Overlapping
+      if (!diff) {
+        return;
+      }
+      diff.push({
+        value: '',
+        lines: []
+      }); // Append an empty value to make cleanup easier
 
-            /*istanbul ignore start*/
+      function contextLines(lines) {
+        return lines.map(function (entry) {
+          return ' ' + entry;
+        });
+      }
+      var hunks = [];
+      var oldRangeStart = 0,
+        newRangeStart = 0,
+        curRange = [],
+        oldLine = 1,
+        newLine = 1;
+      /*istanbul ignore start*/
+      var _loop = function _loop()
+      /*istanbul ignore end*/
+      {
+        var current = diff[i],
+          lines = current.lines || splitLines(current.value);
+        current.lines = lines;
+        if (current.added || current.removed) {
+          /*istanbul ignore start*/
+          var _curRange;
+          /*istanbul ignore end*/
+          // If we have previous context, start with that
+          if (!oldRangeStart) {
+            var prev = diff[i - 1];
+            oldRangeStart = oldLine;
+            newRangeStart = newLine;
+            if (prev) {
+              curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
+              oldRangeStart -= curRange.length;
+              newRangeStart -= curRange.length;
+            }
+          }
 
-            /*istanbul ignore end*/
+          // Output our changes
+          /*istanbul ignore start*/
+          /*istanbul ignore end*/
+          /*istanbul ignore start*/
+          (_curRange =
+          /*istanbul ignore end*/
+          curRange).push.apply(
+          /*istanbul ignore start*/
+          _curRange
+          /*istanbul ignore end*/
+          ,
+          /*istanbul ignore start*/
+          _toConsumableArray$1(
+          /*istanbul ignore end*/
+          lines.map(function (entry) {
+            return (current.added ? '+' : '-') + entry;
+          })));
 
-            /*istanbul ignore start*/
-            (_curRange2 =
-            /*istanbul ignore end*/
-            curRange).push.apply(
-            /*istanbul ignore start*/
-            _curRange2
-            /*istanbul ignore end*/
-            ,
-            /*istanbul ignore start*/
-            _toConsumableArray$1(
-            /*istanbul ignore end*/
-            contextLines(lines)));
+          // Track the updated file position
+          if (current.added) {
+            newLine += lines.length;
           } else {
-            /*istanbul ignore start*/
-            var _curRange3;
-
-            /*istanbul ignore end*/
-            // end the range and output
-            var contextSize = Math.min(lines.length, options.context);
-
-            /*istanbul ignore start*/
-
-            /*istanbul ignore end*/
-
-            /*istanbul ignore start*/
-            (_curRange3 =
-            /*istanbul ignore end*/
-            curRange).push.apply(
-            /*istanbul ignore start*/
-            _curRange3
-            /*istanbul ignore end*/
-            ,
-            /*istanbul ignore start*/
-            _toConsumableArray$1(
-            /*istanbul ignore end*/
-            contextLines(lines.slice(0, contextSize))));
-
-            var hunk = {
-              oldStart: oldRangeStart,
-              oldLines: oldLine - oldRangeStart + contextSize,
-              newStart: newRangeStart,
-              newLines: newLine - newRangeStart + contextSize,
-              lines: curRange
-            };
-
-            if (i >= diff.length - 2 && lines.length <= options.context) {
-              // EOF is inside this hunk
-              var oldEOFNewline = /\n$/.test(oldStr);
-              var newEOFNewline = /\n$/.test(newStr);
-              var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
-
-              if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) {
-                // special case: old has no eol and no trailing context; no-nl can end up before adds
-                // however, if the old file is empty, do not output the no-nl line
-                curRange.splice(hunk.oldLines, 0, '\');
-              }
-
-              if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {
-                curRange.push('\');
-              }
+            oldLine += lines.length;
+          }
+        } else {
+          // Identical context lines. Track line changes
+          if (oldRangeStart) {
+            // Close out any changes that have been output (or join overlapping)
+            if (lines.length <= options.context * 2 && i < diff.length - 2) {
+              /*istanbul ignore start*/
+              var _curRange2;
+              /*istanbul ignore end*/
+              // Overlapping
+              /*istanbul ignore start*/
+              /*istanbul ignore end*/
+              /*istanbul ignore start*/
+              (_curRange2 =
+              /*istanbul ignore end*/
+              curRange).push.apply(
+              /*istanbul ignore start*/
+              _curRange2
+              /*istanbul ignore end*/
+              ,
+              /*istanbul ignore start*/
+              _toConsumableArray$1(
+              /*istanbul ignore end*/
+              contextLines(lines)));
+            } else {
+              /*istanbul ignore start*/
+              var _curRange3;
+              /*istanbul ignore end*/
+              // end the range and output
+              var contextSize = Math.min(lines.length, options.context);
+              /*istanbul ignore start*/
+              /*istanbul ignore end*/
+              /*istanbul ignore start*/
+              (_curRange3 =
+              /*istanbul ignore end*/
+              curRange).push.apply(
+              /*istanbul ignore start*/
+              _curRange3
+              /*istanbul ignore end*/
+              ,
+              /*istanbul ignore start*/
+              _toConsumableArray$1(
+              /*istanbul ignore end*/
+              contextLines(lines.slice(0, contextSize))));
+              var _hunk = {
+                oldStart: oldRangeStart,
+                oldLines: oldLine - oldRangeStart + contextSize,
+                newStart: newRangeStart,
+                newLines: newLine - newRangeStart + contextSize,
+                lines: curRange
+              };
+              hunks.push(_hunk);
+              oldRangeStart = 0;
+              newRangeStart = 0;
+              curRange = [];
             }
-
-            hunks.push(hunk);
-            oldRangeStart = 0;
-            newRangeStart = 0;
-            curRange = [];
           }
+          oldLine += lines.length;
+          newLine += lines.length;
         }
-
-        oldLine += lines.length;
-        newLine += lines.length;
+      };
+      for (var i = 0; i < diff.length; i++)
+      /*istanbul ignore start*/
+      {
+        _loop();
       }
-    };
 
-    for (var i = 0; i < diff.length; i++) {
+      // Step 2: eliminate the trailing `\n` from each line of each hunk, and, where needed, add
+      //         "".
+      /*istanbul ignore end*/
+      for (
+      /*istanbul ignore start*/
+      var _i = 0, _hunks =
+        /*istanbul ignore end*/
+        hunks;
+      /*istanbul ignore start*/
+      _i < _hunks.length
+      /*istanbul ignore end*/
+      ;
       /*istanbul ignore start*/
-      _loop(
+      _i++
       /*istanbul ignore end*/
-      i);
+      ) {
+        var hunk =
+        /*istanbul ignore start*/
+        _hunks[_i]
+        /*istanbul ignore end*/
+        ;
+        for (var _i2 = 0; _i2 < hunk.lines.length; _i2++) {
+          if (hunk.lines[_i2].endsWith('\n')) {
+            hunk.lines[_i2] = hunk.lines[_i2].slice(0, -1);
+          } else {
+            hunk.lines.splice(_i2 + 1, 0, '\');
+            _i2++; // Skip the line we just added, then continue iterating
+          }
+        }
+      }
+      return {
+        oldFileName: oldFileName,
+        newFileName: newFileName,
+        oldHeader: oldHeader,
+        newHeader: newHeader,
+        hunks: hunks
+      };
     }
-
-    return {
-      oldFileName: oldFileName,
-      newFileName: newFileName,
-      oldHeader: oldHeader,
-      newHeader: newHeader,
-      hunks: hunks
-    };
   }
-
   function formatPatch(diff) {
     if (Array.isArray(diff)) {
       return diff.map(formatPatch).join('\n');
     }
-
     var ret = [];
-
     if (diff.oldFileName == diff.newFileName) {
       ret.push('Index: ' + diff.oldFileName);
     }
-
     ret.push('===================================================================');
     ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader));
     ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader));
-
     for (var i = 0; i < diff.hunks.length; i++) {
-      var hunk = diff.hunks[i]; // Unified Diff Format quirk: If the chunk size is 0,
+      var hunk = diff.hunks[i];
+      // Unified Diff Format quirk: If the chunk size is 0,
       // the first number is one lower than one would expect.
       // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
-
       if (hunk.oldLines === 0) {
         hunk.oldStart -= 1;
       }
-
       if (hunk.newLines === 0) {
         hunk.newStart -= 1;
       }
-
       ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');
       ret.push.apply(ret, hunk.lines);
     }
-
-    return ret.join('\n') + '\n';
-  }
-
-  function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-    return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));
+    return ret.join('\n') + '\n';
+  }
+  function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+    /*istanbul ignore start*/
+    var _options2;
+    /*istanbul ignore end*/
+    if (typeof options === 'function') {
+      options = {
+        callback: options
+      };
+    }
+    if (!
+    /*istanbul ignore start*/
+    ((_options2 =
+    /*istanbul ignore end*/
+    options) !== null && _options2 !== void 0 &&
+    /*istanbul ignore start*/
+    _options2
+    /*istanbul ignore end*/
+    .callback)) {
+      var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+      if (!patchObj) {
+        return;
+      }
+      return formatPatch(patchObj);
+    } else {
+      var
+        /*istanbul ignore start*/
+        _options3 =
+        /*istanbul ignore end*/
+        options,
+        /*istanbul ignore start*/
+        /*istanbul ignore end*/
+        _callback2 = _options3.callback;
+      structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader,
+      /*istanbul ignore start*/
+      _objectSpread$1(_objectSpread$1({},
+      /*istanbul ignore end*/
+      options), {}, {
+        callback: function
+        /*istanbul ignore start*/
+        callback
+        /*istanbul ignore end*/
+        (patchObj) {
+          if (!patchObj) {
+            _callback2();
+          } else {
+            _callback2(formatPatch(patchObj));
+          }
+        }
+      }));
+    }
   }
-
   function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
     return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
   }
 
+  /**
+   * Split `text` into an array of lines, including the trailing newline character (where present)
+   */
+  function splitLines(text) {
+    var hasTrailingNl = text.endsWith('\n');
+    var result = text.split('\n').map(function (line)
+    /*istanbul ignore start*/
+    {
+      return (
+        /*istanbul ignore end*/
+        line + '\n'
+      );
+    });
+    if (hasTrailingNl) {
+      result.pop();
+    } else {
+      result.push(result.pop().slice(0, -1));
+    }
+    return result;
+  }
+
   var array = {};
 
   /*istanbul ignore start*/
@@ -7475,27 +8354,22 @@
   });
   array.arrayEqual = arrayEqual;
   array.arrayStartsWith = arrayStartsWith;
-
   /*istanbul ignore end*/
   function arrayEqual(a, b) {
     if (a.length !== b.length) {
       return false;
     }
-
     return arrayStartsWith(a, b);
   }
-
   function arrayStartsWith(array, start) {
     if (start.length > array.length) {
       return false;
     }
-
     for (var i = 0; i < start.length; i++) {
       if (start[i] !== array[i]) {
         return false;
       }
     }
-
     return true;
   }
 
@@ -7506,71 +8380,63 @@
   });
   merge$1.calcLineCount = calcLineCount;
   merge$1.merge = merge;
-
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _create = create
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _parse = parse$2
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _array = array
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
   function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
   function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-  function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
+  function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
   function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
   /*istanbul ignore end*/
   function calcLineCount(hunk) {
-    /*istanbul ignore start*/
-    var _calcOldNewLineCount =
-    /*istanbul ignore end*/
-    calcOldNewLineCount(hunk.lines),
-        oldLines = _calcOldNewLineCount.oldLines,
-        newLines = _calcOldNewLineCount.newLines;
-
+    var
+      /*istanbul ignore start*/
+      _calcOldNewLineCount =
+      /*istanbul ignore end*/
+      calcOldNewLineCount(hunk.lines),
+      /*istanbul ignore start*/
+      /*istanbul ignore end*/
+      oldLines = _calcOldNewLineCount.oldLines,
+      /*istanbul ignore start*/
+      /*istanbul ignore end*/
+      newLines = _calcOldNewLineCount.newLines;
     if (oldLines !== undefined) {
       hunk.oldLines = oldLines;
     } else {
       delete hunk.oldLines;
     }
-
     if (newLines !== undefined) {
       hunk.newLines = newLines;
     } else {
       delete hunk.newLines;
     }
   }
-
   function merge(mine, theirs, base) {
     mine = loadPatch(mine, base);
     theirs = loadPatch(theirs, base);
-    var ret = {}; // For index we just let it pass through as it doesn't have any necessary meaning.
+    var ret = {};
+
+    // For index we just let it pass through as it doesn't have any necessary meaning.
     // Leaving sanity checks on this to the API consumer that may know more about the
     // meaning in their own context.
-
     if (mine.index || theirs.index) {
       ret.index = mine.index || theirs.index;
     }
-
     if (mine.newFileName || theirs.newFileName) {
       if (!fileNameChanged(mine)) {
         // No header or no change in ours, use theirs (and ours if theirs does not exist)
@@ -7592,21 +8458,18 @@
         ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);
       }
     }
-
     ret.hunks = [];
     var mineIndex = 0,
-        theirsIndex = 0,
-        mineOffset = 0,
-        theirsOffset = 0;
-
+      theirsIndex = 0,
+      mineOffset = 0,
+      theirsOffset = 0;
     while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {
       var mineCurrent = mine.hunks[mineIndex] || {
-        oldStart: Infinity
-      },
-          theirsCurrent = theirs.hunks[theirsIndex] || {
-        oldStart: Infinity
-      };
-
+          oldStart: Infinity
+        },
+        theirsCurrent = theirs.hunks[theirsIndex] || {
+          oldStart: Infinity
+        };
       if (hunkBefore(mineCurrent, theirsCurrent)) {
         // This patch does not overlap with any of the others, yay.
         ret.hunks.push(cloneHunk(mineCurrent, mineOffset));
@@ -7632,17 +8495,14 @@
         ret.hunks.push(mergedHunk);
       }
     }
-
     return ret;
   }
-
   function loadPatch(param, base) {
     if (typeof param === 'string') {
       if (/^@@/m.test(param) || /^Index:/m.test(param)) {
         return (
           /*istanbul ignore start*/
           (/*istanbul ignore end*/
-
           /*istanbul ignore start*/
           0, _parse
           /*istanbul ignore end*/
@@ -7653,15 +8513,12 @@
           (param)[0]
         );
       }
-
       if (!base) {
         throw new Error('Must provide a base reference or pass in a patch');
       }
-
       return (
         /*istanbul ignore start*/
         (/*istanbul ignore end*/
-
         /*istanbul ignore start*/
         0, _create
         /*istanbul ignore end*/
@@ -7672,14 +8529,11 @@
         (undefined, undefined, base, param)
       );
     }
-
     return param;
   }
-
   function fileNameChanged(patch) {
     return patch.newFileName && patch.newFileName !== patch.oldFileName;
   }
-
   function selectField(index, mine, theirs) {
     if (mine === theirs) {
       return mine;
@@ -7691,11 +8545,9 @@
       };
     }
   }
-
   function hunkBefore(test, check) {
     return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;
   }
-
   function cloneHunk(hunk, offset) {
     return {
       oldStart: hunk.oldStart,
@@ -7705,42 +8557,38 @@
       lines: hunk.lines
     };
   }
-
   function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {
     // This will generally result in a conflicted hunk, but there are cases where the context
     // is the only overlap where we can successfully merge the content here.
     var mine = {
-      offset: mineOffset,
-      lines: mineLines,
-      index: 0
-    },
-        their = {
-      offset: theirOffset,
-      lines: theirLines,
-      index: 0
-    }; // Handle any leading content
+        offset: mineOffset,
+        lines: mineLines,
+        index: 0
+      },
+      their = {
+        offset: theirOffset,
+        lines: theirLines,
+        index: 0
+      };
 
+    // Handle any leading content
     insertLeading(hunk, mine, their);
-    insertLeading(hunk, their, mine); // Now in the overlap content. Scan through and select the best changes from each.
+    insertLeading(hunk, their, mine);
 
+    // Now in the overlap content. Scan through and select the best changes from each.
     while (mine.index < mine.lines.length && their.index < their.lines.length) {
       var mineCurrent = mine.lines[mine.index],
-          theirCurrent = their.lines[their.index];
-
+        theirCurrent = their.lines[their.index];
       if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {
         // Both modified ...
         mutualChange(hunk, mine, their);
       } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {
         /*istanbul ignore start*/
         var _hunk$lines;
-
         /*istanbul ignore end*/
         // Mine inserted
-
         /*istanbul ignore start*/
-
         /*istanbul ignore end*/
-
         /*istanbul ignore start*/
         (_hunk$lines =
         /*istanbul ignore end*/
@@ -7756,14 +8604,10 @@
       } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {
         /*istanbul ignore start*/
         var _hunk$lines2;
-
         /*istanbul ignore end*/
         // Theirs inserted
-
         /*istanbul ignore start*/
-
         /*istanbul ignore end*/
-
         /*istanbul ignore start*/
         (_hunk$lines2 =
         /*istanbul ignore end*/
@@ -7791,24 +8635,21 @@
         // Context mismatch
         conflict(hunk, collectChange(mine), collectChange(their));
       }
-    } // Now push anything that may be remaining
-
+    }
 
+    // Now push anything that may be remaining
     insertTrailing(hunk, mine);
     insertTrailing(hunk, their);
     calcLineCount(hunk);
   }
-
   function mutualChange(hunk, mine, their) {
     var myChanges = collectChange(mine),
-        theirChanges = collectChange(their);
-
+      theirChanges = collectChange(their);
     if (allRemoves(myChanges) && allRemoves(theirChanges)) {
       // Special case for remove changes that are supersets of one another
       if (
       /*istanbul ignore start*/
       (/*istanbul ignore end*/
-
       /*istanbul ignore start*/
       0, _array
       /*istanbul ignore end*/
@@ -7819,13 +8660,9 @@
       (myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {
         /*istanbul ignore start*/
         var _hunk$lines3;
-
         /*istanbul ignore end*/
-
         /*istanbul ignore start*/
-
         /*istanbul ignore end*/
-
         /*istanbul ignore start*/
         (_hunk$lines3 =
         /*istanbul ignore end*/
@@ -7838,12 +8675,10 @@
         _toConsumableArray(
         /*istanbul ignore end*/
         myChanges));
-
         return;
       } else if (
       /*istanbul ignore start*/
       (/*istanbul ignore end*/
-
       /*istanbul ignore start*/
       0, _array
       /*istanbul ignore end*/
@@ -7854,13 +8689,9 @@
       (theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {
         /*istanbul ignore start*/
         var _hunk$lines4;
-
         /*istanbul ignore end*/
-
         /*istanbul ignore start*/
-
         /*istanbul ignore end*/
-
         /*istanbul ignore start*/
         (_hunk$lines4 =
         /*istanbul ignore end*/
@@ -7873,13 +8704,11 @@
         _toConsumableArray(
         /*istanbul ignore end*/
         theirChanges));
-
         return;
       }
     } else if (
     /*istanbul ignore start*/
     (/*istanbul ignore end*/
-
     /*istanbul ignore start*/
     0, _array
     /*istanbul ignore end*/
@@ -7890,13 +8719,9 @@
     (myChanges, theirChanges)) {
       /*istanbul ignore start*/
       var _hunk$lines5;
-
       /*istanbul ignore end*/
-
       /*istanbul ignore start*/
-
       /*istanbul ignore end*/
-
       /*istanbul ignore start*/
       (_hunk$lines5 =
       /*istanbul ignore end*/
@@ -7909,27 +8734,19 @@
       _toConsumableArray(
       /*istanbul ignore end*/
       myChanges));
-
       return;
     }
-
     conflict(hunk, myChanges, theirChanges);
   }
-
   function removal(hunk, mine, their, swap) {
     var myChanges = collectChange(mine),
-        theirChanges = collectContext(their, myChanges);
-
+      theirChanges = collectContext(their, myChanges);
     if (theirChanges.merged) {
       /*istanbul ignore start*/
       var _hunk$lines6;
-
       /*istanbul ignore end*/
-
       /*istanbul ignore start*/
-
       /*istanbul ignore end*/
-
       /*istanbul ignore start*/
       (_hunk$lines6 =
       /*istanbul ignore end*/
@@ -7946,7 +8763,6 @@
       conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);
     }
   }
-
   function conflict(hunk, mine, their) {
     hunk.conflict = true;
     hunk.lines.push({
@@ -7955,7 +8771,6 @@
       theirs: their
     });
   }
-
   function insertLeading(hunk, insert, their) {
     while (insert.offset < their.offset && insert.index < insert.lines.length) {
       var line = insert.lines[insert.index++];
@@ -7963,25 +8778,22 @@
       insert.offset++;
     }
   }
-
   function insertTrailing(hunk, insert) {
     while (insert.index < insert.lines.length) {
       var line = insert.lines[insert.index++];
       hunk.lines.push(line);
     }
   }
-
   function collectChange(state) {
     var ret = [],
-        operation = state.lines[state.index][0];
-
+      operation = state.lines[state.index][0];
     while (state.index < state.lines.length) {
-      var line = state.lines[state.index]; // Group additions that are immediately after subtractions and treat them as one "atomic" modify change.
+      var line = state.lines[state.index];
 
+      // Group additions that are immediately after subtractions and treat them as one "atomic" modify change.
       if (operation === '-' && line[0] === '+') {
         operation = '+';
       }
-
       if (operation === line[0]) {
         ret.push(line);
         state.index++;
@@ -7989,39 +8801,35 @@
         break;
       }
     }
-
     return ret;
   }
-
   function collectContext(state, matchChanges) {
     var changes = [],
-        merged = [],
-        matchIndex = 0,
-        contextChanges = false,
-        conflicted = false;
-
+      merged = [],
+      matchIndex = 0,
+      contextChanges = false,
+      conflicted = false;
     while (matchIndex < matchChanges.length && state.index < state.lines.length) {
       var change = state.lines[state.index],
-          match = matchChanges[matchIndex]; // Once we've hit our add, then we are done
+        match = matchChanges[matchIndex];
 
+      // Once we've hit our add, then we are done
       if (match[0] === '+') {
         break;
       }
-
       contextChanges = contextChanges || change[0] !== ' ';
       merged.push(match);
-      matchIndex++; // Consume any additions in the other block as a conflict to attempt
-      // to pull in the remaining context after this
+      matchIndex++;
 
+      // Consume any additions in the other block as a conflict to attempt
+      // to pull in the remaining context after this
       if (change[0] === '+') {
         conflicted = true;
-
         while (change[0] === '+') {
           changes.push(change);
           change = state.lines[++state.index];
         }
       }
-
       if (match.substr(1) === change.substr(1)) {
         changes.push(change);
         state.index++;
@@ -8029,44 +8837,35 @@
         conflicted = true;
       }
     }
-
     if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) {
       conflicted = true;
     }
-
     if (conflicted) {
       return changes;
     }
-
     while (matchIndex < matchChanges.length) {
       merged.push(matchChanges[matchIndex++]);
     }
-
     return {
       merged: merged,
       changes: changes
     };
   }
-
   function allRemoves(changes) {
     return changes.reduce(function (prev, change) {
       return prev && change[0] === '-';
     }, true);
   }
-
   function skipRemoveSuperset(state, removeChanges, delta) {
     for (var i = 0; i < delta; i++) {
       var changeContent = removeChanges[removeChanges.length - delta + i].substr(1);
-
       if (state.lines[state.index + i] !== ' ' + changeContent) {
         return false;
       }
     }
-
     state.index += delta;
     return true;
   }
-
   function calcOldNewLineCount(lines) {
     var oldLines = 0;
     var newLines = 0;
@@ -8074,7 +8873,6 @@
       if (typeof line !== 'string') {
         var myCount = calcOldNewLineCount(line.mine);
         var theirCount = calcOldNewLineCount(line.theirs);
-
         if (oldLines !== undefined) {
           if (myCount.oldLines === theirCount.oldLines) {
             oldLines += myCount.oldLines;
@@ -8082,7 +8880,6 @@
             oldLines = undefined;
           }
         }
-
         if (newLines !== undefined) {
           if (myCount.newLines === theirCount.newLines) {
             newLines += myCount.newLines;
@@ -8094,7 +8891,6 @@
         if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {
           newLines++;
         }
-
         if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {
           oldLines++;
         }
@@ -8114,19 +8910,17 @@
     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; }
-
+  function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+  function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+  function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+  function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+  function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
   /*istanbul ignore end*/
   function reversePatch(structuredPatch) {
     if (Array.isArray(structuredPatch)) {
       return structuredPatch.map(reversePatch).reverse();
     }
-
     return (
       /*istanbul ignore start*/
       _objectSpread(_objectSpread({},
@@ -8142,7 +8936,6 @@
             oldStart: hunk.newStart,
             newLines: hunk.oldLines,
             newStart: hunk.oldStart,
-            linedelimiters: hunk.linedelimiters,
             lines: hunk.lines.map(function (l) {
               if (l.startsWith('-')) {
                 return (
@@ -8152,7 +8945,6 @@
                   l.slice(1))
                 );
               }
-
               if (l.startsWith('+')) {
                 return (
                   /*istanbul ignore start*/
@@ -8161,7 +8953,6 @@
                   l.slice(1))
                 );
               }
-
               return l;
             })
           };
@@ -8178,17 +8969,14 @@
     value: true
   });
   dmp.convertChangesToDMP = convertChangesToDMP;
-
   /*istanbul ignore end*/
   // See: http://code.google.com/p/google-diff-match-patch/wiki/API
   function convertChangesToDMP(changes) {
     var ret = [],
-        change,
-        operation;
-
+      change,
+      operation;
     for (var i = 0; i < changes.length; i++) {
       change = changes[i];
-
       if (change.added) {
         operation = 1;
       } else if (change.removed) {
@@ -8196,10 +8984,8 @@
       } else {
         operation = 0;
       }
-
       ret.push([operation, change.value]);
     }
-
     return ret;
   }
 
@@ -8211,32 +8997,25 @@
     value: true
   });
   xml.convertChangesToXML = convertChangesToXML;
-
   /*istanbul ignore end*/
   function convertChangesToXML(changes) {
     var ret = [];
-
     for (var i = 0; i < changes.length; i++) {
       var change = changes[i];
-
       if (change.added) {
         ret.push('<ins>');
       } else if (change.removed) {
         ret.push('<del>');
       }
-
       ret.push(escapeHTML(change.value));
-
       if (change.added) {
         ret.push('</ins>');
       } else if (change.removed) {
         ret.push('</del>');
       }
     }
-
     return ret.join('');
   }
-
   function escapeHTML(s) {
     var n = s;
     n = n.replace(/&/g, '&amp;');
@@ -8259,226 +9038,209 @@
       return _base["default"];
     }
   });
-  Object.defineProperty(exports, "diffChars", {
+  Object.defineProperty(exports, "applyPatch", {
     enumerable: true,
     get: function get() {
-      return _character.diffChars;
+      return _apply.applyPatch;
     }
   });
-  Object.defineProperty(exports, "diffWords", {
+  Object.defineProperty(exports, "applyPatches", {
     enumerable: true,
     get: function get() {
-      return _word.diffWords;
+      return _apply.applyPatches;
     }
   });
-  Object.defineProperty(exports, "diffWordsWithSpace", {
+  Object.defineProperty(exports, "canonicalize", {
     enumerable: true,
     get: function get() {
-      return _word.diffWordsWithSpace;
+      return _json.canonicalize;
     }
   });
-  Object.defineProperty(exports, "diffLines", {
+  Object.defineProperty(exports, "convertChangesToDMP", {
     enumerable: true,
     get: function get() {
-      return _line.diffLines;
+      return _dmp.convertChangesToDMP;
     }
   });
-  Object.defineProperty(exports, "diffTrimmedLines", {
+  Object.defineProperty(exports, "convertChangesToXML", {
     enumerable: true,
     get: function get() {
-      return _line.diffTrimmedLines;
+      return _xml.convertChangesToXML;
     }
   });
-  Object.defineProperty(exports, "diffSentences", {
+  Object.defineProperty(exports, "createPatch", {
     enumerable: true,
     get: function get() {
-      return _sentence.diffSentences;
+      return _create.createPatch;
     }
   });
-  Object.defineProperty(exports, "diffCss", {
+  Object.defineProperty(exports, "createTwoFilesPatch", {
     enumerable: true,
     get: function get() {
-      return _css.diffCss;
+      return _create.createTwoFilesPatch;
     }
   });
-  Object.defineProperty(exports, "diffJson", {
+  Object.defineProperty(exports, "diffArrays", {
     enumerable: true,
     get: function get() {
-      return _json.diffJson;
+      return _array.diffArrays;
     }
   });
-  Object.defineProperty(exports, "canonicalize", {
+  Object.defineProperty(exports, "diffChars", {
     enumerable: true,
     get: function get() {
-      return _json.canonicalize;
+      return _character.diffChars;
     }
   });
-  Object.defineProperty(exports, "diffArrays", {
+  Object.defineProperty(exports, "diffCss", {
     enumerable: true,
     get: function get() {
-      return _array.diffArrays;
+      return _css.diffCss;
     }
   });
-  Object.defineProperty(exports, "applyPatch", {
+  Object.defineProperty(exports, "diffJson", {
     enumerable: true,
     get: function get() {
-      return _apply.applyPatch;
+      return _json.diffJson;
     }
   });
-  Object.defineProperty(exports, "applyPatches", {
+  Object.defineProperty(exports, "diffLines", {
     enumerable: true,
     get: function get() {
-      return _apply.applyPatches;
+      return _line.diffLines;
     }
   });
-  Object.defineProperty(exports, "parsePatch", {
+  Object.defineProperty(exports, "diffSentences", {
     enumerable: true,
     get: function get() {
-      return _parse.parsePatch;
+      return _sentence.diffSentences;
     }
   });
-  Object.defineProperty(exports, "merge", {
+  Object.defineProperty(exports, "diffTrimmedLines", {
     enumerable: true,
     get: function get() {
-      return _merge.merge;
+      return _line.diffTrimmedLines;
     }
   });
-  Object.defineProperty(exports, "reversePatch", {
+  Object.defineProperty(exports, "diffWords", {
     enumerable: true,
     get: function get() {
-      return _reverse.reversePatch;
+      return _word.diffWords;
     }
   });
-  Object.defineProperty(exports, "structuredPatch", {
+  Object.defineProperty(exports, "diffWordsWithSpace", {
     enumerable: true,
     get: function get() {
-      return _create.structuredPatch;
+      return _word.diffWordsWithSpace;
     }
   });
-  Object.defineProperty(exports, "createTwoFilesPatch", {
+  Object.defineProperty(exports, "formatPatch", {
     enumerable: true,
     get: function get() {
-      return _create.createTwoFilesPatch;
+      return _create.formatPatch;
     }
   });
-  Object.defineProperty(exports, "createPatch", {
+  Object.defineProperty(exports, "merge", {
     enumerable: true,
     get: function get() {
-      return _create.createPatch;
+      return _merge.merge;
     }
   });
-  Object.defineProperty(exports, "formatPatch", {
+  Object.defineProperty(exports, "parsePatch", {
     enumerable: true,
     get: function get() {
-      return _create.formatPatch;
+      return _parse.parsePatch;
     }
   });
-  Object.defineProperty(exports, "convertChangesToDMP", {
+  Object.defineProperty(exports, "reversePatch", {
     enumerable: true,
     get: function get() {
-      return _dmp.convertChangesToDMP;
+      return _reverse.reversePatch;
     }
   });
-  Object.defineProperty(exports, "convertChangesToXML", {
+  Object.defineProperty(exports, "structuredPatch", {
     enumerable: true,
     get: function get() {
-      return _xml.convertChangesToXML;
+      return _create.structuredPatch;
     }
   });
-
   /*istanbul ignore end*/
   var
   /*istanbul ignore start*/
   _base = _interopRequireDefault(base)
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _character = character
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _word = word
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _line = line
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _sentence = sentence
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _css = css
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _json = json$1
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _array = array$1
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _apply = apply
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _parse = parse$2
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _merge = merge$1
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _reverse = reverse
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _create = create
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _dmp = dmp
   /*istanbul ignore end*/
   ;
-
   var
   /*istanbul ignore start*/
   _xml = xml
   /*istanbul ignore end*/
   ;
-
   /*istanbul ignore start*/ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
   /*istanbul ignore end*/
 
   }(lib));
@@ -19256,7 +20018,7 @@
   };
 
   var name = "mocha";
-  var version = "11.3.0";
+  var version = "11.5.0";
   var homepage = "https://mochajs.org/";
   var notifyLogo = "https://ibin.co/4QuRuGjXvl36.png";
   var require$$17 = {