bkui-vue 2.0.2-beta.45 → 2.0.2-beta.47

package/lib/code-diff/index.js

@@ -1004,9 +1004,10 @@ var x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
 var y = x => () => x
 const shared_namespaceObject = x({ ["PropTypes"]: () => __WEBPACK_EXTERNAL_MODULE_bkui_vue_lib_shared_edbdfb03__.PropTypes, ["classes"]: () => __WEBPACK_EXTERNAL_MODULE_bkui_vue_lib_shared_edbdfb03__.classes, ["stringEnum"]: () => __WEBPACK_EXTERNAL_MODULE_bkui_vue_lib_shared_edbdfb03__.stringEnum, ["withInstall"]: () => __WEBPACK_EXTERNAL_MODULE_bkui_vue_lib_shared_edbdfb03__.withInstall });
 ;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
 }
+
 ;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
 function _iterableToArrayLimit(r, l) {
   var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
@@ -1035,34 +1036,38 @@ function _iterableToArrayLimit(r, l) {
     return a;
   }
 }
+
 ;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
-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(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
 }
+
 ;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 
-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 _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
 }
+
 ;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
 function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+
 ;// CONCATENATED MODULE: ../../node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 
 
 
 
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
+
 ;// CONCATENATED MODULE: external "vue"
 var external_vue_x = y => { var x = {}; __webpack_require__.d(x, y); return x; }
 var external_vue_y = x => () => x
@@ -2693,6 +2698,14 @@ function hashCode(text) {
     }
     return hash;
 }
+function max(arr) {
+    const length = arr.length;
+    let max = -Infinity;
+    for (let i = 0; i < length; i++) {
+        max = Math.max(max, arr[i]);
+    }
+    return max;
+}
 //# sourceMappingURL=utils.js.map
 ;// CONCATENATED MODULE: ../../node_modules/diff2html/lib-esm/diff-parser.js
 
@@ -3009,7 +3022,8 @@ function parse(diffInput, config = {}) {
         else if ((values = index.exec(line))) {
             currentFile.checksumBefore = values[1];
             currentFile.checksumAfter = values[2];
-            values[3] && (currentFile.mode = values[3]);
+            if (values[3])
+                currentFile.mode = values[3];
         }
         else if ((values = combinedIndex.exec(line))) {
             currentFile.checksumBefore = [values[2], values[3]];
@@ -3037,211 +3051,245 @@ function parse(diffInput, config = {}) {
 function lib_Diff() {}
 lib_Diff.prototype = {
   diff: function diff(oldString, newString) {
+    var _options$timeout;
     var 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 = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
+    var abortAfterTimestamp = Date.now() + maxExecutionTime;
     var bestPath = [{
-      newPos: -1,
-      components: []
-    }]; // Seed editLength = 0, i.e. the content starts with the same values
-
-    var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+      oldPos: -1,
+      lastComponent: undefined
+    }];
 
-    if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+    // 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
-      }]);
-    } // Main worker method. checks all permutations of a given edit length for acceptance.
-
-
+      return done(lib_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).
+    // Similarly, once we've reached the bottom of the edit graph, there's no
+    // point considering moves to lower diagonals.
+    // We record this fact by setting minDiagonalToConsider and
+    // maxDiagonalToConsider to some finite value once we've hit the edge of
+    // the edit graph.
+    // This optimization is not faithful to the original algorithm presented in
+    // Myers's paper, which instead pointlessly extends D-paths off the end of
+    // the edit graph - see page 7 of Myers's paper which notes this point
+    // explicitly and illustrates it with a diagram. This has major performance
+    // implications for some common scenarios. For instance, to compute a diff
+    // where the new text simply appends d characters on the end of the
+    // original text of length n, the true Myers algorithm will take O(n+d^2)
+    // time while this optimization needs only O(n+d) time.
+    var minDiagonalToConsider = -Infinity,
+      maxDiagonalToConsider = Infinity;
+
+    // Main worker method. checks all permutations of a given edit length for acceptance.
     function execEditLength() {
-      for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
+      for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
         var basePath = void 0;
-
-        var addPath = bestPath[diagonalPath - 1],
-            removePath = bestPath[diagonalPath + 1],
-            _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
-
-        if (addPath) {
+        var removePath = 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 = addPath && addPath.newPos + 1 < newLen,
-            canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
-
+        var canAdd = false;
+        if (addPath) {
+          // what newPos will be after we do an insertion:
+          var addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        var canRemove = removePath && removePath.oldPos + 1 < oldLen;
         if (!canAdd && !canRemove) {
           // If this path is a terminal then prune
           bestPath[diagonalPath] = undefined;
           continue;
-        } // Select the diagonal that we want to branch from. We select the prior
-        // path whose position in the new string is the farthest from the origin
-        // and does not pass the bounds of the diff graph
-
+        }
 
-        if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
-          basePath = lib_clonePath(removePath);
-          self.pushComponent(basePath.components, undefined, true);
+        // 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
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = self.addToPath(addPath, true, false, 0, options);
         } else {
-          basePath = addPath; // No need to clone, we've pulled it from the list
-
-          basePath.newPos++;
-          self.pushComponent(basePath.components, true, undefined);
+          basePath = self.addToPath(removePath, false, true, 1, options);
         }
-
-        _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done
-
-        if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
-          return done(lib_buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
+        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(lib_buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
         } else {
-          // Otherwise track this path as a potential candidate and continue.
           bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
         }
       }
-
       editLength++;
-    } // Performs the length of edit iteration. Is a bit fugly as this has to support the
+    }
+
+    // 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) {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
             return callback();
           }
-
           if (!execEditLength()) {
             exec();
           }
         }, 0);
       })();
     } else {
-      while (editLength <= maxEditLength) {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
         var ret = execEditLength();
-
         if (ret) {
           return ret;
         }
       }
     }
   },
-  pushComponent: function pushComponent(components, added, removed) {
-    var last = components[components.length - 1];
-
-    if (last && last.added === added && last.removed === removed) {
-      // We need to clone here as the component clone operation is just
-      // as shallow array clone
-      components[components.length - 1] = {
-        count: last.count + 1,
-        added: added,
-        removed: removed
+  addToPath: function addToPath(path, added, removed, oldPosInc, options) {
+    var last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: {
+          count: last.count + 1,
+          added: added,
+          removed: removed,
+          previousComponent: last.previousComponent
+        }
       };
     } else {
-      components.push({
-        count: 1,
-        added: added,
-        removed: removed
-      });
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: {
+          count: 1,
+          added: added,
+          removed: removed,
+          previousComponent: last
+        }
+      };
     }
   },
-  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
+  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath, options) {
     var newLen = newString.length,
-        oldLen = oldString.length,
-        newPos = basePath.newPos,
-        oldPos = newPos - 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) {
-      basePath.components.push({
-        count: commonCount
-      });
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = {
+        count: commonCount,
+        previousComponent: basePath.lastComponent,
+        added: false,
+        removed: false
+      };
     }
-
-    basePath.newPos = newPos;
-    return oldPos;
+    basePath.oldPos = oldPos;
+    return newPos;
   },
-  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();
     }
   },
   removeEmpty: function removeEmpty(array) {
     var ret = [];
-
     for (var i = 0; i < array.length; i++) {
       if (array[i]) {
         ret.push(array[i]);
       }
     }
-
     return ret;
   },
   castInput: function castInput(value) {
     return value;
   },
   tokenize: function tokenize(value) {
-    return value.split('');
+    return Array.from(value);
   },
   join: function join(chars) {
     return chars.join('');
+  },
+  postProcess: function postProcess(changeObjects) {
+    return changeObjects;
   }
 };
-
-function lib_buildValues(diff, components, newString, oldString, useLongestToken) {
+function lib_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);
@@ -3253,66 +3301,133 @@ function lib_buildValues(diff, components, newString, oldString, useLongestToken
       } 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 lastComponent = components[componentLen - 1];
-
-  if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
-    components[componentLen - 2].value += lastComponent.value;
-    components.pop();
   }
-
   return components;
 }
 
-function lib_clonePath(path) {
-  return {
-    newPos: path.newPos,
-    components: path.components.slice(0)
-  };
-}
-
 var lib_characterDiff = new lib_Diff();
 function lib_diffChars(oldStr, newStr, options) {
   return lib_characterDiff.diff(oldStr, newStr, options);
 }
 
-function lib_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("string ".concat(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("string ".concat(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');
 }
 
+// Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode
 //
 // Ranges and exceptions:
 // Latin-1 Supplement, 0080–00FF
@@ -3330,77 +3445,330 @@ function lib_generateOptions(options, defaults) {
 //  - U+02DC  ˜ &#732;  Small Tilde
 //  - U+02DD  ˝ &#733;  Double Acute Accent
 // Latin Extended Additional, 1E00–1EFF
+var lib_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}";
 
-var lib_extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
-var lib_reWhitespace = /\S/;
+// 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("[".concat(lib_extendedWordChars, "]+|\\s+|[^").concat(lib_extendedWordChars, "]"), 'ug');
 var lib_wordDiff = new lib_Diff();
-
-lib_wordDiff.equals = function (left, right) {
-  if (this.options.ignoreCase) {
+lib_wordDiff.equals = function (left, right, options) {
+  if (options.ignoreCase) {
     left = left.toLowerCase();
     right = right.toLowerCase();
   }
-
-  return left === right || this.options.ignoreWhitespace && !lib_reWhitespace.test(left) && !lib_reWhitespace.test(right);
+  return left.trim() === right.trim();
 };
-
 lib_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] && lib_extendedWordChars.test(tokens[i]) && lib_extendedWordChars.test(tokens[i + 2])) {
-      tokens[i] += tokens[i + 2];
-      tokens.splice(i + 1, 2);
-      i--;
+  var 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) {
+      return 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 tokens;
 };
-
-function lib_diffWords(oldStr, newStr, options) {
-  options = lib_generateOptions(options, {
-    ignoreWhitespace: true
+lib_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('');
+};
+lib_wordDiff.postProcess = function (changes, options) {
+  if (!changes || options.oneChangePerToken) {
+    return changes;
+  }
+  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 (insertion || deletion) {
+        // May be false at start of text
+        dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+      }
+      lastKeep = change;
+      insertion = null;
+      deletion = null;
+    }
   });
+  if (insertion || deletion) {
+    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
+  }
+  return changes;
+};
+function lib_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 ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
+    return lib_diffWordsWithSpace(oldStr, newStr, options);
+  }
   return lib_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 = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+      deletion.value = removePrefix(deletion.value, commonWsPrefix);
+      insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      var commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+      insertion.value = removeSuffix(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 = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(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 = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd);
+    endKeep.value = replacePrefix(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 = replaceSuffix(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 = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(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 = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, _overlap);
+  }
+}
+var wordWithSpaceDiff = new lib_Diff();
+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("(\\r?\\n)|[".concat(lib_extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(lib_extendedWordChars, "]"), 'ug');
+  return value.match(regex) || [];
+};
 function lib_diffWordsWithSpace(oldStr, newStr, options) {
-  return lib_wordDiff.diff(oldStr, newStr, options);
+  return wordWithSpaceDiff.diff(oldStr, newStr, options);
 }
 
-var lib_lineDiff = new lib_Diff();
-
-lib_lineDiff.tokenize = function (value) {
+function lib_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;
+}
+
+var lib_lineDiff = new lib_Diff();
+lib_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
+    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
-
+  }
 
+  // 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) {
+    if (i % 2 && !options.newlineIsToken) {
       retLines[retLines.length - 1] += line;
     } else {
-      if (this.options.ignoreWhitespace) {
-        line = line.trim();
-      }
-
       retLines.push(line);
     }
   }
-
   return retLines;
 };
-
+lib_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 lib_Diff.prototype.equals.call(this, left, right, options);
+};
 function lib_diffLines(oldStr, newStr, callback) {
   return lib_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 lib_diffTrimmedLines(oldStr, newStr, callback) {
   var options = lib_generateOptions(callback, {
     ignoreWhitespace: true
@@ -3409,53 +3777,88 @@ function lib_diffTrimmedLines(oldStr, newStr, callback) {
 }
 
 var lib_sentenceDiff = new lib_Diff();
-
 lib_sentenceDiff.tokenize = function (value) {
   return value.split(/(\S.+?[.!?])(?=\s+|$)/);
 };
-
 function lib_diffSentences(oldStr, newStr, callback) {
   return lib_sentenceDiff.diff(oldStr, newStr, callback);
 }
 
 var lib_cssDiff = new lib_Diff();
-
 lib_cssDiff.tokenize = function (value) {
   return value.split(/([{}:;,]|\s+)/);
 };
-
 function lib_diffCss(oldStr, newStr, callback) {
   return lib_cssDiff.diff(oldStr, newStr, callback);
 }
 
-function lib_typeof(obj) {
+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 _objectSpread2(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 _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);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function lib_typeof(o) {
   "@babel/helpers - typeof";
 
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    lib_typeof = function (obj) {
-      return typeof obj;
-    };
+  return lib_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;
+  }, lib_typeof(o);
+}
+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 {
-    lib_typeof = function (obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    };
+    obj[key] = value;
   }
-
-  return lib_typeof(obj);
+  return obj;
 }
-
 function lib_toConsumableArray(arr) {
   return lib_arrayWithoutHoles(arr) || lib_iterableToArray(arr) || diff_lib_unsupportedIterableToArray(arr) || lib_nonIterableSpread();
 }
-
 function lib_arrayWithoutHoles(arr) {
   if (Array.isArray(arr)) return diff_lib_arrayLikeToArray(arr);
 }
-
 function lib_iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-
 function diff_lib_unsupportedIterableToArray(o, minLen) {
   if (!o) return;
   if (typeof o === "string") return diff_lib_arrayLikeToArray(o, minLen);
@@ -3464,238 +3867,263 @@ function diff_lib_unsupportedIterableToArray(o, minLen) {
   if (n === "Map" || n === "Set") return Array.from(o);
   if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return diff_lib_arrayLikeToArray(o, minLen);
 }
-
 function diff_lib_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 lib_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.");
 }
 
-var lib_objectPrototypeToString = Object.prototype.toString;
-var lib_jsonDiff = new lib_Diff(); // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
+var lib_jsonDiff = new lib_Diff();
+// 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:
-
 lib_jsonDiff.useLongestToken = true;
 lib_jsonDiff.tokenize = lib_lineDiff.tokenize;
-
-lib_jsonDiff.castInput = function (value) {
-  var _this$options = this.options,
-      undefinedReplacement = _this$options.undefinedReplacement,
-      _this$options$stringi = _this$options.stringifyReplacer,
-      stringifyReplacer = _this$options$stringi === void 0 ? function (k, v) {
-    return typeof v === 'undefined' ? undefinedReplacement : v;
-  } : _this$options$stringi;
+lib_jsonDiff.castInput = function (value, options) {
+  var undefinedReplacement = options.undefinedReplacement,
+    _options$stringifyRep = options.stringifyReplacer,
+    stringifyReplacer = _options$stringifyRep === void 0 ? function (k, v) {
+      return typeof v === 'undefined' ? undefinedReplacement : v;
+    } : _options$stringifyRep;
   return typeof value === 'string' ? value : JSON.stringify(lib_canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, '  ');
 };
-
-lib_jsonDiff.equals = function (left, right) {
-  return lib_Diff.prototype.equals.call(lib_jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'));
+lib_jsonDiff.equals = function (left, right, options) {
+  return lib_Diff.prototype.equals.call(lib_jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
 };
-
 function lib_diffJson(oldObj, newObj, options) {
   return lib_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 lib_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]' === lib_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] = lib_canonicalize(obj[i], stack, replacementStack, replacer, key);
     }
-
     stack.pop();
     replacementStack.pop();
     return canonicalizedObj;
   }
-
   if (obj && obj.toJSON) {
     obj = obj.toJSON();
   }
-
   if (lib_typeof(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] = lib_canonicalize(obj[_key], stack, replacementStack, replacer, _key);
     }
-
     stack.pop();
     replacementStack.pop();
   } else {
     canonicalizedObj = obj;
   }
-
   return canonicalizedObj;
 }
 
 var lib_arrayDiff = new lib_Diff();
-
 lib_arrayDiff.tokenize = function (value) {
   return value.slice();
 };
-
 lib_arrayDiff.join = lib_arrayDiff.removeEmpty = function (value) {
   return value;
 };
-
 function lib_diffArrays(oldArr, newArr, callback) {
   return lib_arrayDiff.diff(oldArr, newArr, callback);
 }
 
-function lib_parsePatch(uniDiff) {
-  var 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;
+function unixToWin(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(unixToWin);
+  }
+  return _objectSpread2(_objectSpread2({}, patch), {}, {
+    hunks: patch.hunks.map(function (hunk) {
+      return _objectSpread2(_objectSpread2({}, hunk), {}, {
+        lines: hunk.lines.map(function (line, i) {
+          var _hunk$lines;
+          return line.startsWith('\\') || line.endsWith('\r') || (_hunk$lines = hunk.lines[i + 1]) !== null && _hunk$lines !== void 0 && _hunk$lines.startsWith('\\') ? line : line + '\r';
+        })
+      });
+    })
+  });
+}
+function winToUnix(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(winToUnix);
+  }
+  return _objectSpread2(_objectSpread2({}, patch), {}, {
+    hunks: patch.hunks.map(function (hunk) {
+      return _objectSpread2(_objectSpread2({}, hunk), {}, {
+        lines: hunk.lines.map(function (line) {
+          return 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) {
+    return index.hunks.some(function (hunk) {
+      return hunk.lines.some(function (line) {
+        return !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) {
+    return index.hunks.some(function (hunk) {
+      return hunk.lines.some(function (line) {
+        return line.endsWith('\r');
+      });
+    });
+  }) && patch.every(function (index) {
+    return index.hunks.every(function (hunk) {
+      return hunk.lines.every(function (line, i) {
+        var _hunk$lines2;
+        return line.startsWith('\\') || line.endsWith('\r') || ((_hunk$lines2 = hunk.lines[i + 1]) === null || _hunk$lines2 === void 0 ? void 0 : _hunk$lines2.startsWith('\\'));
+      });
+    });
+  });
+}
+
+function lib_parsePatch(uniDiff) {
+  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 || (_diffstr$i = diffstr[i]) !== null && _diffstr$i !== void 0 && _diffstr$i.startsWith('\\')); i++) {
+      var _diffstr$i;
       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 === '-') {
@@ -3705,37 +4133,30 @@ function lib_parsePatch(uniDiff) {
           removeCount++;
         }
       } else {
-        break;
+        throw new Error("Hunk at line ".concat(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;
 }
 
@@ -3744,210 +4165,275 @@ function lib_parsePatch(uniDiff) {
 // start of 2, this will iterate 2, 3, 1, 4, 0.
 function lib_distanceIterator (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
   };
 }
 
 function lib_applyPatch(source, uniDiff) {
   var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
   if (typeof uniDiff === 'string') {
     uniDiff = lib_parsePatch(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
-
-
-  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) {
-    return line === patchContent;
-  },
-      errorCount = 0,
-      fuzzFactor = options.fuzzFactor || 0,
-      minLine = 0,
-      offset = 0,
-      removeEOFNL,
-      addEOFNL;
-  /**
-   * Checks if the hunk exactly fits on the provided location
-   */
+  }
+  if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
+    if (hasOnlyWinLineEndings(source) && isUnix(uniDiff)) {
+      uniDiff = unixToWin(uniDiff);
+    } else if (hasOnlyUnixLineEndings(source) && isWin(uniDiff)) {
+      uniDiff = winToUnix(uniDiff);
+    }
+  }
 
+  // Apply the diff to the input
+  var lines = source.split('\n'),
+    hunks = uniDiff.hunks,
+    compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) {
+      return line === patchContent;
+    },
+    fuzzFactor = options.fuzzFactor || 0,
+    minLine = 0;
+  if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
+    throw new Error('fuzzFactor must be a non-negative integer');
+  }
 
-  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;
+  // Special case for empty patch.
+  if (!hunks.length) {
+    return source;
+  }
 
-      if (operation === ' ' || operation === '-') {
-        // Context sanity check
-        if (!compareLine(toPos + 1, lines[toPos], operation, content)) {
-          errorCount++;
+  // 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;
+    }
+  }
 
-          if (errorCount > fuzzFactor) {
-            return false;
+  /**
+   * 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 applyHunk(hunkLines, toPos, maxErrors) {
+    var hunkLinesI = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    var lastContextLineMatched = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+    var patchedLines = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+    var 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 = lib_distanceIterator(toPos, minLine, maxLine);
+    // 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 = [];
 
-    for (; localOffset !== undefined; localOffset = iterator()) {
-      if (hunkFits(hunk, toPos + localOffset)) {
-        hunk.offset = offset += localOffset;
+  // 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 = void 0;
+    var maxLine = lines.length - hunk.oldLines + fuzzFactor;
+    var toPos = void 0;
+    for (var maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
+      toPos = hunk.oldStart + prevHunkOffset - 1;
+      var iterator = lib_distanceIterator(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[j];
+    }
 
-      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;
+    // 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 (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 lib_applyPatches(uniDiff, options) {
   if (typeof uniDiff === 'string') {
     uniDiff = lib_parsePatch(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 = lib_applyPatch(data, index, options);
       options.patched(index, updatedContent, function (err) {
         if (err) {
           return options.complete(err);
         }
-
         processIndex();
       });
     });
   }
-
   processIndex();
 }
 
@@ -3955,202 +4441,238 @@ function lib_structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader
   if (!options) {
     options = {};
   }
-
+  if (typeof options === 'function') {
+    options = {
+      callback: options
+    };
+  }
   if (typeof options.context === 'undefined') {
     options.context = 4;
   }
-
-  var diff = lib_diffLines(oldStr, newStr, options);
-
-  if (!diff) {
-    return;
+  if (options.newlineIsToken) {
+    throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');
+  }
+  if (!options.callback) {
+    return diffLinesResultToPatch(lib_diffLines(oldStr, newStr, options));
+  } else {
+    var _options = options,
+      _callback = _options.callback;
+    lib_diffLines(oldStr, newStr, _objectSpread2(_objectSpread2({}, options), {}, {
+      callback: function callback(diff) {
+        var patch = diffLinesResultToPatch(diff);
+        _callback(patch);
+      }
+    }));
   }
+  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...
 
-  diff.push({
-    value: '',
-    lines: []
-  }); // Append an empty value to make cleanup easier
-
-  function contextLines(lines) {
-    return lines.map(function (entry) {
-      return ' ' + entry;
-    });
-  }
+    if (!diff) {
+      return;
+    }
+    diff.push({
+      value: '',
+      lines: []
+    }); // Append an empty value to make cleanup easier
 
-  var hunks = [];
-  var oldRangeStart = 0,
+    function contextLines(lines) {
+      return lines.map(function (entry) {
+        return ' ' + entry;
+      });
+    }
+    var hunks = [];
+    var oldRangeStart = 0,
       newRangeStart = 0,
       curRange = [],
       oldLine = 1,
       newLine = 1;
-
-  var _loop = function _loop(i) {
-    var current = diff[i],
-        lines = current.lines || current.value.replace(/\n$/, '').split('\n');
-    current.lines = lines;
-
-    if (current.added || current.removed) {
-      var _curRange;
-
-      // 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;
+    var _loop = function _loop() {
+      var current = diff[i],
+        lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        var _curRange;
+        // 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
-
-
-      (_curRange = curRange).push.apply(_curRange, lib_toConsumableArray(lines.map(function (entry) {
-        return (current.added ? '+' : '-') + entry;
-      }))); // Track the updated file position
 
+        // Output our changes
+        (_curRange = curRange).push.apply(_curRange, lib_toConsumableArray(lines.map(function (entry) {
+          return (current.added ? '+' : '-') + entry;
+        })));
 
-      if (current.added) {
-        newLine += lines.length;
+        // Track the updated file position
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          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) {
+            var _curRange2;
+            // Overlapping
+            (_curRange2 = curRange).push.apply(_curRange2, lib_toConsumableArray(contextLines(lines)));
+          } else {
+            var _curRange3;
+            // end the range and output
+            var contextSize = Math.min(lines.length, options.context);
+            (_curRange3 = curRange).push.apply(_curRange3, lib_toConsumableArray(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 = [];
+          }
+        }
         oldLine += lines.length;
+        newLine += 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) {
-          var _curRange2;
+    };
+    for (var i = 0; i < diff.length; i++) {
+      _loop();
+    }
 
-          // Overlapping
-          (_curRange2 = curRange).push.apply(_curRange2, lib_toConsumableArray(contextLines(lines)));
+    // Step 2: eliminate the trailing `\n` from each line of each hunk, and, where needed, add
+    //         "".
+    for (var _i = 0, _hunks = hunks; _i < _hunks.length; _i++) {
+      var hunk = _hunks[_i];
+      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 {
-          var _curRange3;
-
-          // end the range and output
-          var contextSize = Math.min(lines.length, options.context);
-
-          (_curRange3 = curRange).push.apply(_curRange3, lib_toConsumableArray(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('\');
-            }
-          }
-
-          hunks.push(hunk);
-          oldRangeStart = 0;
-          newRangeStart = 0;
-          curRange = [];
+          hunk.lines.splice(_i2 + 1, 0, '\');
+          _i2++; // Skip the line we just added, then continue iterating
         }
       }
-
-      oldLine += lines.length;
-      newLine += lines.length;
     }
-  };
-
-  for (var i = 0; i < diff.length; i++) {
-    _loop(i);
+    return {
+      oldFileName: oldFileName,
+      newFileName: newFileName,
+      oldHeader: oldHeader,
+      newHeader: newHeader,
+      hunks: hunks
+    };
   }
-
-  return {
-    oldFileName: oldFileName,
-    newFileName: newFileName,
-    oldHeader: oldHeader,
-    newHeader: newHeader,
-    hunks: hunks
-  };
 }
 function lib_formatPatch(diff) {
+  if (Array.isArray(diff)) {
+    return diff.map(lib_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 lib_createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  return lib_formatPatch(lib_structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));
+  var _options2;
+  if (typeof options === 'function') {
+    options = {
+      callback: options
+    };
+  }
+  if (!((_options2 = options) !== null && _options2 !== void 0 && _options2.callback)) {
+    var patchObj = lib_structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return lib_formatPatch(patchObj);
+  } else {
+    var _options3 = options,
+      _callback2 = _options3.callback;
+    lib_structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, _objectSpread2(_objectSpread2({}, options), {}, {
+      callback: function callback(patchObj) {
+        if (!patchObj) {
+          _callback2();
+        } else {
+          _callback2(lib_formatPatch(patchObj));
+        }
+      }
+    }));
+  }
 }
 function lib_createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
   return lib_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) {
+    return line + '\n';
+  });
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
 function lib_arrayEqual(a, b) {
   if (a.length !== b.length) {
     return false;
   }
-
   return lib_arrayStartsWith(a, b);
 }
 function lib_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;
 }
 
 function lib_calcLineCount(hunk) {
   var _calcOldNewLineCount = lib_calcOldNewLineCount(hunk.lines),
-      oldLines = _calcOldNewLineCount.oldLines,
-      newLines = _calcOldNewLineCount.newLines;
-
+    oldLines = _calcOldNewLineCount.oldLines,
+    newLines = _calcOldNewLineCount.newLines;
   if (oldLines !== undefined) {
     hunk.oldLines = oldLines;
   } else {
     delete hunk.oldLines;
   }
-
   if (newLines !== undefined) {
     hunk.newLines = newLines;
   } else {
@@ -4160,14 +4682,14 @@ function lib_calcLineCount(hunk) {
 function lib_merge(mine, theirs, base) {
   mine = lib_loadPatch(mine, base);
   theirs = lib_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 (!lib_fileNameChanged(mine)) {
       // No header or no change in ours, use theirs (and ours if theirs does not exist)
@@ -4189,21 +4711,18 @@ function lib_merge(mine, theirs, base) {
       ret.newHeader = lib_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 (lib_hunkBefore(mineCurrent, theirsCurrent)) {
       // This patch does not overlap with any of the others, yay.
       ret.hunks.push(lib_cloneHunk(mineCurrent, mineOffset));
@@ -4229,30 +4748,23 @@ function lib_merge(mine, theirs, base) {
       ret.hunks.push(mergedHunk);
     }
   }
-
   return ret;
 }
-
 function lib_loadPatch(param, base) {
   if (typeof param === 'string') {
     if (/^@@/m.test(param) || /^Index:/m.test(param)) {
       return lib_parsePatch(param)[0];
     }
-
     if (!base) {
       throw new Error('Must provide a base reference or pass in a patch');
     }
-
     return lib_structuredPatch(undefined, undefined, base, param);
   }
-
   return param;
 }
-
 function lib_fileNameChanged(patch) {
   return patch.newFileName && patch.newFileName !== patch.oldFileName;
 }
-
 function lib_selectField(index, mine, theirs) {
   if (mine === theirs) {
     return mine;
@@ -4264,11 +4776,9 @@ function lib_selectField(index, mine, theirs) {
     };
   }
 }
-
 function lib_hunkBefore(test, check) {
   return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;
 }
-
 function lib_cloneHunk(hunk, offset) {
   return {
     oldStart: hunk.oldStart,
@@ -4278,39 +4788,37 @@ function lib_cloneHunk(hunk, offset) {
     lines: hunk.lines
   };
 }
-
 function lib_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
   lib_insertLeading(hunk, mine, their);
-  lib_insertLeading(hunk, their, mine); // Now in the overlap content. Scan through and select the best changes from each.
+  lib_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 ...
       lib_mutualChange(hunk, mine, their);
     } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {
       var _hunk$lines;
-
       // Mine inserted
       (_hunk$lines = hunk.lines).push.apply(_hunk$lines, lib_toConsumableArray(lib_collectChange(mine)));
     } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {
       var _hunk$lines2;
-
       // Theirs inserted
       (_hunk$lines2 = hunk.lines).push.apply(_hunk$lines2, lib_toConsumableArray(lib_collectChange(their)));
     } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {
@@ -4328,57 +4836,44 @@ function lib_mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {
       // Context mismatch
       lib_conflict(hunk, lib_collectChange(mine), lib_collectChange(their));
     }
-  } // Now push anything that may be remaining
-
+  }
 
+  // Now push anything that may be remaining
   lib_insertTrailing(hunk, mine);
   lib_insertTrailing(hunk, their);
   lib_calcLineCount(hunk);
 }
-
 function lib_mutualChange(hunk, mine, their) {
   var myChanges = lib_collectChange(mine),
-      theirChanges = lib_collectChange(their);
-
+    theirChanges = lib_collectChange(their);
   if (lib_allRemoves(myChanges) && lib_allRemoves(theirChanges)) {
     // Special case for remove changes that are supersets of one another
     if (lib_arrayStartsWith(myChanges, theirChanges) && lib_skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {
       var _hunk$lines3;
-
       (_hunk$lines3 = hunk.lines).push.apply(_hunk$lines3, lib_toConsumableArray(myChanges));
-
       return;
     } else if (lib_arrayStartsWith(theirChanges, myChanges) && lib_skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {
       var _hunk$lines4;
-
       (_hunk$lines4 = hunk.lines).push.apply(_hunk$lines4, lib_toConsumableArray(theirChanges));
-
       return;
     }
   } else if (lib_arrayEqual(myChanges, theirChanges)) {
     var _hunk$lines5;
-
     (_hunk$lines5 = hunk.lines).push.apply(_hunk$lines5, lib_toConsumableArray(myChanges));
-
     return;
   }
-
   lib_conflict(hunk, myChanges, theirChanges);
 }
-
 function lib_removal(hunk, mine, their, swap) {
   var myChanges = lib_collectChange(mine),
-      theirChanges = lib_collectContext(their, myChanges);
-
+    theirChanges = lib_collectContext(their, myChanges);
   if (theirChanges.merged) {
     var _hunk$lines6;
-
     (_hunk$lines6 = hunk.lines).push.apply(_hunk$lines6, lib_toConsumableArray(theirChanges.merged));
   } else {
     lib_conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);
   }
 }
-
 function lib_conflict(hunk, mine, their) {
   hunk.conflict = true;
   hunk.lines.push({
@@ -4387,7 +4882,6 @@ function lib_conflict(hunk, mine, their) {
     theirs: their
   });
 }
-
 function lib_insertLeading(hunk, insert, their) {
   while (insert.offset < their.offset && insert.index < insert.lines.length) {
     var line = insert.lines[insert.index++];
@@ -4395,25 +4889,22 @@ function lib_insertLeading(hunk, insert, their) {
     insert.offset++;
   }
 }
-
 function lib_insertTrailing(hunk, insert) {
   while (insert.index < insert.lines.length) {
     var line = insert.lines[insert.index++];
     hunk.lines.push(line);
   }
 }
-
 function lib_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++;
@@ -4421,39 +4912,35 @@ function lib_collectChange(state) {
       break;
     }
   }
-
   return ret;
 }
-
 function lib_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++;
@@ -4461,44 +4948,35 @@ function lib_collectContext(state, matchChanges) {
       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 lib_allRemoves(changes) {
   return changes.reduce(function (prev, change) {
     return prev && change[0] === '-';
   }, true);
 }
-
 function lib_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 lib_calcOldNewLineCount(lines) {
   var oldLines = 0;
   var newLines = 0;
@@ -4506,7 +4984,6 @@ function lib_calcOldNewLineCount(lines) {
     if (typeof line !== 'string') {
       var myCount = lib_calcOldNewLineCount(line.mine);
       var theirCount = lib_calcOldNewLineCount(line.theirs);
-
       if (oldLines !== undefined) {
         if (myCount.oldLines === theirCount.oldLines) {
           oldLines += myCount.oldLines;
@@ -4514,7 +4991,6 @@ function lib_calcOldNewLineCount(lines) {
           oldLines = undefined;
         }
       }
-
       if (newLines !== undefined) {
         if (myCount.newLines === theirCount.newLines) {
           newLines += myCount.newLines;
@@ -4526,7 +5002,6 @@ function lib_calcOldNewLineCount(lines) {
       if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {
         newLines++;
       }
-
       if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {
         oldLines++;
       }
@@ -4538,15 +5013,42 @@ function lib_calcOldNewLineCount(lines) {
   };
 }
 
+function reversePatch(structuredPatch) {
+  if (Array.isArray(structuredPatch)) {
+    return structuredPatch.map(reversePatch).reverse();
+  }
+  return _objectSpread2(_objectSpread2({}, structuredPatch), {}, {
+    oldFileName: structuredPatch.newFileName,
+    oldHeader: structuredPatch.newHeader,
+    newFileName: structuredPatch.oldFileName,
+    newHeader: structuredPatch.oldHeader,
+    hunks: structuredPatch.hunks.map(function (hunk) {
+      return {
+        oldLines: hunk.newLines,
+        oldStart: hunk.newStart,
+        newLines: hunk.oldLines,
+        newStart: hunk.oldStart,
+        lines: hunk.lines.map(function (l) {
+          if (l.startsWith('-')) {
+            return "+".concat(l.slice(1));
+          }
+          if (l.startsWith('+')) {
+            return "-".concat(l.slice(1));
+          }
+          return l;
+        })
+      };
+    })
+  });
+}
+
 // See: http://code.google.com/p/google-diff-match-patch/wiki/API
 function lib_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) {
@@ -4554,37 +5056,29 @@ function lib_convertChangesToDMP(changes) {
     } else {
       operation = 0;
     }
-
     ret.push([operation, change.value]);
   }
-
   return ret;
 }
 
 function lib_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(lib_escapeHTML(change.value));
-
     if (change.added) {
       ret.push('</ins>');
     } else if (change.removed) {
       ret.push('</del>');
     }
   }
-
   return ret.join('');
 }
-
 function lib_escapeHTML(s) {
   var n = s;
   n = n.replace(/&/g, '&amp;');
@@ -4921,6 +5415,7 @@ class FileListRenderer {
 
 
 
+
 const defaultLineByLineRendererConfig = Object.assign(Object.assign({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 });
 const genericTemplatesPath = 'generic';
 const line_by_line_renderer_baseTemplatesPath = 'line-by-line';
@@ -5051,7 +5546,7 @@ class LineByLineRenderer {
     }
     applyRematchMatching(oldLines, newLines, matcher) {
         const comparisons = oldLines.length * newLines.length;
-        const maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(elem => elem.content.length)));
+        const maxLineSizeInBlock = max(oldLines.concat(newLines).map(elem => elem.content.length));
         const doMatching = comparisons < this.config.matchingMaxComparisons &&
             maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison &&
             (this.config.matching === 'lines' || this.config.matching === 'words');
@@ -5121,6 +5616,7 @@ class LineByLineRenderer {
 
 
 
+
 const defaultSideBySideRendererConfig = Object.assign(Object.assign({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 });
 const side_by_side_renderer_genericTemplatesPath = 'generic';
 const side_by_side_renderer_baseTemplatesPath = 'side-by-side';
@@ -5260,7 +5756,7 @@ class SideBySideRenderer {
     }
     applyRematchMatching(oldLines, newLines, matcher) {
         const comparisons = oldLines.length * newLines.length;
-        const maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(elem => elem.content.length)));
+        const maxLineSizeInBlock = max(oldLines.concat(newLines).map(elem => elem.content.length));
         const doMatching = comparisons < this.config.matchingMaxComparisons &&
             maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison &&
             (this.config.matching === 'lines' || this.config.matching === 'words');
@@ -5390,7 +5886,7 @@ class HoganJsUtils {
             const template = this.preCompiledTemplates[templateKey];
             return template.render(params, partials, indent);
         }
-        catch (e) {
+        catch (_e) {
             throw new Error(`Could not find template to render '${templateKey}'`);
         }
     }