v5

node_modules/jest-diff/build/cleanupSemantic.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Diff Match and Patch
+ * Copyright 2018 The diff-match-patch Authors.
+ * https://github.com/google/diff-match-patch
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @fileoverview Computes the difference between two texts to create a patch.
+ * Applies the patch onto another text, allowing for errors.
+ * @author fraser@google.com (Neil Fraser)
+ */
+/**
+ * CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
+ *
+ * 1. Delete anything not needed to use diff_cleanupSemantic method
+ * 2. Convert from prototype properties to var declarations
+ * 3. Convert Diff to class from constructor and prototype
+ * 4. Add type annotations for arguments and return values
+ * 5. Add exports
+ */
+/**
+ * The data structure representing a diff is an array of tuples:
+ * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
+ * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
+ */
+declare var DIFF_DELETE: number;
+declare var DIFF_INSERT: number;
+declare var DIFF_EQUAL: number;
+/**
+ * Class representing one diff tuple.
+ * Attempts to look like a two-element array (which is what this used to be).
+ * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
+ * @param {string} text Text to be deleted, inserted, or retained.
+ * @constructor
+ */
+declare class Diff {
+    0: number;
+    1: string;
+    constructor(op: number, text: string);
+}
+/**
+ * Reduce the number of edits by eliminating semantically trivial equalities.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+declare var diff_cleanupSemantic: (diffs: Diff[]) => void;
+export { Diff, DIFF_EQUAL, DIFF_DELETE, DIFF_INSERT, diff_cleanupSemantic as cleanupSemantic, };
+//# sourceMappingURL=cleanupSemantic.d.ts.map

node_modules/jest-diff/build/cleanupSemantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanupSemantic.d.ts","sourceRoot":"","sources":["../src/cleanupSemantic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;GAIG;AACH,QAAA,IAAI,WAAW,QAAK,CAAC;AACrB,QAAA,IAAI,WAAW,QAAI,CAAC;AACpB,QAAA,IAAI,UAAU,QAAI,CAAC;AAEnB;;;;;;GAMG;AACH,cAAM,IAAI;IACR,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;gBAEE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAIrC;AAoHD;;;GAGG;AACF,QAAA,IAAI,oBAAoB,yBA0GxB,CAAC;AAyQF,OAAO,EACL,IAAI,EACJ,UAAU,EACV,WAAW,EACX,WAAW,EACX,oBAAoB,IAAI,eAAe,GACxC,CAAC"}

node_modules/jest-diff/build/cleanupSemantic.js

@@ -0,0 +1,653 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.cleanupSemantic = exports.DIFF_INSERT = exports.DIFF_DELETE = exports.DIFF_EQUAL = exports.Diff = void 0;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+/**
+ * Diff Match and Patch
+ * Copyright 2018 The diff-match-patch Authors.
+ * https://github.com/google/diff-match-patch
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Computes the difference between two texts to create a patch.
+ * Applies the patch onto another text, allowing for errors.
+ * @author fraser@google.com (Neil Fraser)
+ */
+
+/**
+ * CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
+ *
+ * 1. Delete anything not needed to use diff_cleanupSemantic method
+ * 2. Convert from prototype properties to var declarations
+ * 3. Convert Diff to class from constructor and prototype
+ * 4. Add type annotations for arguments and return values
+ * 5. Add exports
+ */
+
+/**
+ * The data structure representing a diff is an array of tuples:
+ * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
+ * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
+ */
+var DIFF_DELETE = -1;
+exports.DIFF_DELETE = DIFF_DELETE;
+var DIFF_INSERT = 1;
+exports.DIFF_INSERT = DIFF_INSERT;
+var DIFF_EQUAL = 0;
+/**
+ * Class representing one diff tuple.
+ * Attempts to look like a two-element array (which is what this used to be).
+ * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
+ * @param {string} text Text to be deleted, inserted, or retained.
+ * @constructor
+ */
+
+exports.DIFF_EQUAL = DIFF_EQUAL;
+
+class Diff {
+  constructor(op, text) {
+    _defineProperty(this, 0, void 0);
+
+    _defineProperty(this, 1, void 0);
+
+    this[0] = op;
+    this[1] = text;
+  }
+}
+/**
+ * Determine the common prefix of two strings.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {number} The number of characters common to the start of each
+ *     string.
+ */
+
+exports.Diff = Diff;
+
+var diff_commonPrefix = function diff_commonPrefix(text1, text2) {
+  // Quick check for common null cases.
+  if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
+    return 0;
+  } // Binary search.
+  // Performance analysis: https://neil.fraser.name/news/2007/10/09/
+
+  var pointermin = 0;
+  var pointermax = Math.min(text1.length, text2.length);
+  var pointermid = pointermax;
+  var pointerstart = 0;
+
+  while (pointermin < pointermid) {
+    if (
+      text1.substring(pointerstart, pointermid) ==
+      text2.substring(pointerstart, pointermid)
+    ) {
+      pointermin = pointermid;
+      pointerstart = pointermin;
+    } else {
+      pointermax = pointermid;
+    }
+
+    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+  }
+
+  return pointermid;
+};
+/**
+ * Determine the common suffix of two strings.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {number} The number of characters common to the end of each string.
+ */
+
+var diff_commonSuffix = function diff_commonSuffix(text1, text2) {
+  // Quick check for common null cases.
+  if (
+    !text1 ||
+    !text2 ||
+    text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)
+  ) {
+    return 0;
+  } // Binary search.
+  // Performance analysis: https://neil.fraser.name/news/2007/10/09/
+
+  var pointermin = 0;
+  var pointermax = Math.min(text1.length, text2.length);
+  var pointermid = pointermax;
+  var pointerend = 0;
+
+  while (pointermin < pointermid) {
+    if (
+      text1.substring(text1.length - pointermid, text1.length - pointerend) ==
+      text2.substring(text2.length - pointermid, text2.length - pointerend)
+    ) {
+      pointermin = pointermid;
+      pointerend = pointermin;
+    } else {
+      pointermax = pointermid;
+    }
+
+    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+  }
+
+  return pointermid;
+};
+/**
+ * Determine if the suffix of one string is the prefix of another.
+ * @param {string} text1 First string.
+ * @param {string} text2 Second string.
+ * @return {number} The number of characters common to the end of the first
+ *     string and the start of the second string.
+ * @private
+ */
+
+var diff_commonOverlap_ = function diff_commonOverlap_(text1, text2) {
+  // Cache the text lengths to prevent multiple calls.
+  var text1_length = text1.length;
+  var text2_length = text2.length; // Eliminate the null case.
+
+  if (text1_length == 0 || text2_length == 0) {
+    return 0;
+  } // Truncate the longer string.
+
+  if (text1_length > text2_length) {
+    text1 = text1.substring(text1_length - text2_length);
+  } else if (text1_length < text2_length) {
+    text2 = text2.substring(0, text1_length);
+  }
+
+  var text_length = Math.min(text1_length, text2_length); // Quick check for the worst case.
+
+  if (text1 == text2) {
+    return text_length;
+  } // Start by looking for a single character match
+  // and increase length until no match is found.
+  // Performance analysis: https://neil.fraser.name/news/2010/11/04/
+
+  var best = 0;
+  var length = 1;
+
+  while (true) {
+    var pattern = text1.substring(text_length - length);
+    var found = text2.indexOf(pattern);
+
+    if (found == -1) {
+      return best;
+    }
+
+    length += found;
+
+    if (
+      found == 0 ||
+      text1.substring(text_length - length) == text2.substring(0, length)
+    ) {
+      best = length;
+      length++;
+    }
+  }
+};
+/**
+ * Reduce the number of edits by eliminating semantically trivial equalities.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+
+var diff_cleanupSemantic = function diff_cleanupSemantic(diffs) {
+  var changes = false;
+  var equalities = []; // Stack of indices where equalities are found.
+
+  var equalitiesLength = 0; // Keeping our own length var is faster in JS.
+
+  /** @type {?string} */
+
+  var lastEquality = null; // Always equal to diffs[equalities[equalitiesLength - 1]][1]
+
+  var pointer = 0; // Index of current position.
+  // Number of characters that changed prior to the equality.
+
+  var length_insertions1 = 0;
+  var length_deletions1 = 0; // Number of characters that changed after the equality.
+
+  var length_insertions2 = 0;
+  var length_deletions2 = 0;
+
+  while (pointer < diffs.length) {
+    if (diffs[pointer][0] == DIFF_EQUAL) {
+      // Equality found.
+      equalities[equalitiesLength++] = pointer;
+      length_insertions1 = length_insertions2;
+      length_deletions1 = length_deletions2;
+      length_insertions2 = 0;
+      length_deletions2 = 0;
+      lastEquality = diffs[pointer][1];
+    } else {
+      // An insertion or deletion.
+      if (diffs[pointer][0] == DIFF_INSERT) {
+        length_insertions2 += diffs[pointer][1].length;
+      } else {
+        length_deletions2 += diffs[pointer][1].length;
+      } // Eliminate an equality that is smaller or equal to the edits on both
+      // sides of it.
+
+      if (
+        lastEquality &&
+        lastEquality.length <=
+          Math.max(length_insertions1, length_deletions1) &&
+        lastEquality.length <= Math.max(length_insertions2, length_deletions2)
+      ) {
+        // Duplicate record.
+        diffs.splice(
+          equalities[equalitiesLength - 1],
+          0,
+          new Diff(DIFF_DELETE, lastEquality)
+        ); // Change second copy to insert.
+
+        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; // Throw away the equality we just deleted.
+
+        equalitiesLength--; // Throw away the previous equality (it needs to be reevaluated).
+
+        equalitiesLength--;
+        pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
+        length_insertions1 = 0; // Reset the counters.
+
+        length_deletions1 = 0;
+        length_insertions2 = 0;
+        length_deletions2 = 0;
+        lastEquality = null;
+        changes = true;
+      }
+    }
+
+    pointer++;
+  } // Normalize the diff.
+
+  if (changes) {
+    diff_cleanupMerge(diffs);
+  }
+
+  diff_cleanupSemanticLossless(diffs); // Find any overlaps between deletions and insertions.
+  // e.g: <del>abcxxx</del><ins>xxxdef</ins>
+  //   -> <del>abc</del>xxx<ins>def</ins>
+  // e.g: <del>xxxabc</del><ins>defxxx</ins>
+  //   -> <ins>def</ins>xxx<del>abc</del>
+  // Only extract an overlap if it is as big as the edit ahead or behind it.
+
+  pointer = 1;
+
+  while (pointer < diffs.length) {
+    if (
+      diffs[pointer - 1][0] == DIFF_DELETE &&
+      diffs[pointer][0] == DIFF_INSERT
+    ) {
+      var deletion = diffs[pointer - 1][1];
+      var insertion = diffs[pointer][1];
+      var overlap_length1 = diff_commonOverlap_(deletion, insertion);
+      var overlap_length2 = diff_commonOverlap_(insertion, deletion);
+
+      if (overlap_length1 >= overlap_length2) {
+        if (
+          overlap_length1 >= deletion.length / 2 ||
+          overlap_length1 >= insertion.length / 2
+        ) {
+          // Overlap found.  Insert an equality and trim the surrounding edits.
+          diffs.splice(
+            pointer,
+            0,
+            new Diff(DIFF_EQUAL, insertion.substring(0, overlap_length1))
+          );
+          diffs[pointer - 1][1] = deletion.substring(
+            0,
+            deletion.length - overlap_length1
+          );
+          diffs[pointer + 1][1] = insertion.substring(overlap_length1);
+          pointer++;
+        }
+      } else {
+        if (
+          overlap_length2 >= deletion.length / 2 ||
+          overlap_length2 >= insertion.length / 2
+        ) {
+          // Reverse overlap found.
+          // Insert an equality and swap and trim the surrounding edits.
+          diffs.splice(
+            pointer,
+            0,
+            new Diff(DIFF_EQUAL, deletion.substring(0, overlap_length2))
+          );
+          diffs[pointer - 1][0] = DIFF_INSERT;
+          diffs[pointer - 1][1] = insertion.substring(
+            0,
+            insertion.length - overlap_length2
+          );
+          diffs[pointer + 1][0] = DIFF_DELETE;
+          diffs[pointer + 1][1] = deletion.substring(overlap_length2);
+          pointer++;
+        }
+      }
+
+      pointer++;
+    }
+
+    pointer++;
+  }
+};
+/**
+ * Look for single edits surrounded on both sides by equalities
+ * which can be shifted sideways to align the edit to a word boundary.
+ * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+
+exports.cleanupSemantic = diff_cleanupSemantic;
+
+var diff_cleanupSemanticLossless = function diff_cleanupSemanticLossless(
+  diffs
+) {
+  /**
+   * Given two strings, compute a score representing whether the internal
+   * boundary falls on logical boundaries.
+   * Scores range from 6 (best) to 0 (worst).
+   * Closure, but does not reference any external variables.
+   * @param {string} one First string.
+   * @param {string} two Second string.
+   * @return {number} The score.
+   * @private
+   */
+  function diff_cleanupSemanticScore_(one, two) {
+    if (!one || !two) {
+      // Edges are the best.
+      return 6;
+    } // Each port of this function behaves slightly differently due to
+    // subtle differences in each language's definition of things like
+    // 'whitespace'.  Since this function's purpose is largely cosmetic,
+    // the choice has been made to use each language's native features
+    // rather than force total conformity.
+
+    var char1 = one.charAt(one.length - 1);
+    var char2 = two.charAt(0);
+    var nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);
+    var nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);
+    var whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);
+    var whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);
+    var lineBreak1 = whitespace1 && char1.match(linebreakRegex_);
+    var lineBreak2 = whitespace2 && char2.match(linebreakRegex_);
+    var blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);
+    var blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);
+
+    if (blankLine1 || blankLine2) {
+      // Five points for blank lines.
+      return 5;
+    } else if (lineBreak1 || lineBreak2) {
+      // Four points for line breaks.
+      return 4;
+    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
+      // Three points for end of sentences.
+      return 3;
+    } else if (whitespace1 || whitespace2) {
+      // Two points for whitespace.
+      return 2;
+    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
+      // One point for non-alphanumeric.
+      return 1;
+    }
+
+    return 0;
+  }
+
+  var pointer = 1; // Intentionally ignore the first and last element (don't need checking).
+
+  while (pointer < diffs.length - 1) {
+    if (
+      diffs[pointer - 1][0] == DIFF_EQUAL &&
+      diffs[pointer + 1][0] == DIFF_EQUAL
+    ) {
+      // This is a single edit surrounded by equalities.
+      var equality1 = diffs[pointer - 1][1];
+      var edit = diffs[pointer][1];
+      var equality2 = diffs[pointer + 1][1]; // First, shift the edit as far left as possible.
+
+      var commonOffset = diff_commonSuffix(equality1, edit);
+
+      if (commonOffset) {
+        var commonString = edit.substring(edit.length - commonOffset);
+        equality1 = equality1.substring(0, equality1.length - commonOffset);
+        edit = commonString + edit.substring(0, edit.length - commonOffset);
+        equality2 = commonString + equality2;
+      } // Second, step character by character right, looking for the best fit.
+
+      var bestEquality1 = equality1;
+      var bestEdit = edit;
+      var bestEquality2 = equality2;
+      var bestScore =
+        diff_cleanupSemanticScore_(equality1, edit) +
+        diff_cleanupSemanticScore_(edit, equality2);
+
+      while (edit.charAt(0) === equality2.charAt(0)) {
+        equality1 += edit.charAt(0);
+        edit = edit.substring(1) + equality2.charAt(0);
+        equality2 = equality2.substring(1);
+        var score =
+          diff_cleanupSemanticScore_(equality1, edit) +
+          diff_cleanupSemanticScore_(edit, equality2); // The >= encourages trailing rather than leading whitespace on edits.
+
+        if (score >= bestScore) {
+          bestScore = score;
+          bestEquality1 = equality1;
+          bestEdit = edit;
+          bestEquality2 = equality2;
+        }
+      }
+
+      if (diffs[pointer - 1][1] != bestEquality1) {
+        // We have an improvement, save it back to the diff.
+        if (bestEquality1) {
+          diffs[pointer - 1][1] = bestEquality1;
+        } else {
+          diffs.splice(pointer - 1, 1);
+          pointer--;
+        }
+
+        diffs[pointer][1] = bestEdit;
+
+        if (bestEquality2) {
+          diffs[pointer + 1][1] = bestEquality2;
+        } else {
+          diffs.splice(pointer + 1, 1);
+          pointer--;
+        }
+      }
+    }
+
+    pointer++;
+  }
+}; // Define some regex patterns for matching boundaries.
+
+var nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
+var whitespaceRegex_ = /\s/;
+var linebreakRegex_ = /[\r\n]/;
+var blanklineEndRegex_ = /\n\r?\n$/;
+var blanklineStartRegex_ = /^\r?\n\r?\n/;
+/**
+ * Reorder and merge like edit sections.  Merge equalities.
+ * Any edit section can move as long as it doesn't cross an equality.
+ * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+ */
+
+var diff_cleanupMerge = function diff_cleanupMerge(diffs) {
+  // Add a dummy entry at the end.
+  diffs.push(new Diff(DIFF_EQUAL, ''));
+  var pointer = 0;
+  var count_delete = 0;
+  var count_insert = 0;
+  var text_delete = '';
+  var text_insert = '';
+  var commonlength;
+
+  while (pointer < diffs.length) {
+    switch (diffs[pointer][0]) {
+      case DIFF_INSERT:
+        count_insert++;
+        text_insert += diffs[pointer][1];
+        pointer++;
+        break;
+
+      case DIFF_DELETE:
+        count_delete++;
+        text_delete += diffs[pointer][1];
+        pointer++;
+        break;
+
+      case DIFF_EQUAL:
+        // Upon reaching an equality, check for prior redundancies.
+        if (count_delete + count_insert > 1) {
+          if (count_delete !== 0 && count_insert !== 0) {
+            // Factor out any common prefixies.
+            commonlength = diff_commonPrefix(text_insert, text_delete);
+
+            if (commonlength !== 0) {
+              if (
+                pointer - count_delete - count_insert > 0 &&
+                diffs[pointer - count_delete - count_insert - 1][0] ==
+                  DIFF_EQUAL
+              ) {
+                diffs[
+                  pointer - count_delete - count_insert - 1
+                ][1] += text_insert.substring(0, commonlength);
+              } else {
+                diffs.splice(
+                  0,
+                  0,
+                  new Diff(DIFF_EQUAL, text_insert.substring(0, commonlength))
+                );
+                pointer++;
+              }
+
+              text_insert = text_insert.substring(commonlength);
+              text_delete = text_delete.substring(commonlength);
+            } // Factor out any common suffixies.
+
+            commonlength = diff_commonSuffix(text_insert, text_delete);
+
+            if (commonlength !== 0) {
+              diffs[pointer][1] =
+                text_insert.substring(text_insert.length - commonlength) +
+                diffs[pointer][1];
+              text_insert = text_insert.substring(
+                0,
+                text_insert.length - commonlength
+              );
+              text_delete = text_delete.substring(
+                0,
+                text_delete.length - commonlength
+              );
+            }
+          } // Delete the offending records and add the merged ones.
+
+          pointer -= count_delete + count_insert;
+          diffs.splice(pointer, count_delete + count_insert);
+
+          if (text_delete.length) {
+            diffs.splice(pointer, 0, new Diff(DIFF_DELETE, text_delete));
+            pointer++;
+          }
+
+          if (text_insert.length) {
+            diffs.splice(pointer, 0, new Diff(DIFF_INSERT, text_insert));
+            pointer++;
+          }
+
+          pointer++;
+        } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {
+          // Merge this equality with the previous one.
+          diffs[pointer - 1][1] += diffs[pointer][1];
+          diffs.splice(pointer, 1);
+        } else {
+          pointer++;
+        }
+
+        count_insert = 0;
+        count_delete = 0;
+        text_delete = '';
+        text_insert = '';
+        break;
+    }
+  }
+
+  if (diffs[diffs.length - 1][1] === '') {
+    diffs.pop(); // Remove the dummy entry at the end.
+  } // Second pass: look for single edits surrounded on both sides by equalities
+  // which can be shifted sideways to eliminate an equality.
+  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
+
+  var changes = false;
+  pointer = 1; // Intentionally ignore the first and last element (don't need checking).
+
+  while (pointer < diffs.length - 1) {
+    if (
+      diffs[pointer - 1][0] == DIFF_EQUAL &&
+      diffs[pointer + 1][0] == DIFF_EQUAL
+    ) {
+      // This is a single edit surrounded by equalities.
+      if (
+        diffs[pointer][1].substring(
+          diffs[pointer][1].length - diffs[pointer - 1][1].length
+        ) == diffs[pointer - 1][1]
+      ) {
+        // Shift the edit over the previous equality.
+        diffs[pointer][1] =
+          diffs[pointer - 1][1] +
+          diffs[pointer][1].substring(
+            0,
+            diffs[pointer][1].length - diffs[pointer - 1][1].length
+          );
+        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
+        diffs.splice(pointer - 1, 1);
+        changes = true;
+      } else if (
+        diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==
+        diffs[pointer + 1][1]
+      ) {
+        // Shift the edit over the next equality.
+        diffs[pointer - 1][1] += diffs[pointer + 1][1];
+        diffs[pointer][1] =
+          diffs[pointer][1].substring(diffs[pointer + 1][1].length) +
+          diffs[pointer + 1][1];
+        diffs.splice(pointer + 1, 1);
+        changes = true;
+      }
+    }
+
+    pointer++;
+  } // If shifts were made, the diff needs reordering and another shift sweep.
+
+  if (changes) {
+    diff_cleanupMerge(diffs);
+  }
+};

node_modules/jest-diff/build/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare const NO_DIFF_MESSAGE: string;
+export declare const SIMILAR_MESSAGE: string;
+//# sourceMappingURL=constants.d.ts.map

node_modules/jest-diff/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,eAAe,QAE3B,CAAC;AAEF,eAAO,MAAM,eAAe,QAG3B,CAAC"}

node_modules/jest-diff/build/constants.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.SIMILAR_MESSAGE = exports.NO_DIFF_MESSAGE = void 0;
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const NO_DIFF_MESSAGE = _chalk.default.dim(
+  'Compared values have no visual difference.'
+);
+
+exports.NO_DIFF_MESSAGE = NO_DIFF_MESSAGE;
+
+const SIMILAR_MESSAGE = _chalk.default.dim(
+  'Compared values serialize to the same structure.\n' +
+    'Printing internal object structure without calling `toJSON` instead.'
+);
+
+exports.SIMILAR_MESSAGE = SIMILAR_MESSAGE;

node_modules/jest-diff/build/diffLines.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { DiffOptions } from './types';
+declare type Original = {
+    a: string;
+    b: string;
+};
+declare const _default: (a: string, b: string, options?: DiffOptions | undefined, original?: Original | undefined) => string;
+export default _default;
+//# sourceMappingURL=diffLines.d.ts.map

node_modules/jest-diff/build/diffLines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffLines.d.ts","sourceRoot":"","sources":["../src/diffLines.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,EAAC,WAAW,EAAC,MAAM,SAAS,CAAC;AAIpC,aAAK,QAAQ,GAAG;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;;AAmQF,wBA6CE"}

node_modules/jest-diff/build/diffLines.js

@@ -0,0 +1,290 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _diffSequences = _interopRequireDefault(require('diff-sequences'));
+
+var _constants = require('./constants');
+
+var _printDiffs = require('./printDiffs');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const DIFF_CONTEXT_DEFAULT = 5;
+const fgDelete = _chalk.default.green;
+const fgInsert = _chalk.default.red;
+const fgCommon = _chalk.default.dim; // common lines (even indentation same)
+
+const fgIndent = _chalk.default.cyan; // common lines (only indentation different)
+
+const bgCommon = _chalk.default.bgYellow; // edge spaces in common line (even indentation same)
+
+const bgInverse = _chalk.default.inverse; // edge spaces in any other lines
+// ONLY trailing if expected value is snapshot or multiline string.
+
+const highlightTrailingSpaces = (line, bgColor) =>
+  line.replace(/\s+$/, bgColor('$&')); // BOTH leading AND trailing if expected value is data structure.
+
+const highlightLeadingTrailingSpaces = (
+  line,
+  bgColor // If line consists of ALL spaces: highlight all of them.
+) =>
+  highlightTrailingSpaces(line, bgColor).replace(
+    // If line has an ODD length of leading spaces: highlight only the LAST.
+    /^(\s\s)*(\s)(?=[^\s])/,
+    '$1' + bgColor('$2')
+  );
+
+const getHighlightSpaces = bothEdges =>
+  bothEdges ? highlightLeadingTrailingSpaces : highlightTrailingSpaces;
+
+// Given index interval in expected lines, put formatted delete lines.
+const formatDelete = (aStart, aEnd, aLinesUn, aLinesIn, put) => {
+  const highlightSpaces = getHighlightSpaces(aLinesUn !== aLinesIn);
+
+  for (let aIndex = aStart; aIndex !== aEnd; aIndex += 1) {
+    const aLineUn = aLinesUn[aIndex];
+    const aLineIn = aLinesIn[aIndex];
+    const indentation = aLineIn.slice(0, aLineIn.length - aLineUn.length);
+    put(fgDelete('- ' + indentation + highlightSpaces(aLineUn, bgInverse)));
+  }
+}; // Given index interval in received lines, put formatted insert lines.
+
+const formatInsert = (bStart, bEnd, bLinesUn, bLinesIn, put) => {
+  const highlightSpaces = getHighlightSpaces(bLinesUn !== bLinesIn);
+
+  for (let bIndex = bStart; bIndex !== bEnd; bIndex += 1) {
+    const bLineUn = bLinesUn[bIndex];
+    const bLineIn = bLinesIn[bIndex];
+    const indentation = bLineIn.slice(0, bLineIn.length - bLineUn.length);
+    put(fgInsert('+ ' + indentation + highlightSpaces(bLineUn, bgInverse)));
+  }
+}; // Given the number of items and starting indexes of a common subsequence,
+// put formatted common lines.
+
+const formatCommon = (
+  nCommon,
+  aCommon,
+  bCommon,
+  aLinesIn,
+  bLinesUn,
+  bLinesIn,
+  put
+) => {
+  const highlightSpaces = getHighlightSpaces(bLinesUn !== bLinesIn);
+
+  for (; nCommon !== 0; nCommon -= 1, aCommon += 1, bCommon += 1) {
+    const bLineUn = bLinesUn[bCommon];
+    const bLineIn = bLinesIn[bCommon];
+    const bLineInLength = bLineIn.length; // For common lines, received indentation seems more intuitive.
+
+    const indentation = bLineIn.slice(0, bLineInLength - bLineUn.length); // Color shows whether expected and received line has same indentation.
+
+    const hasSameIndentation = aLinesIn[aCommon].length === bLineInLength;
+    const fg = hasSameIndentation ? fgCommon : fgIndent;
+    const bg = hasSameIndentation ? bgCommon : bgInverse;
+    put(fg('  ' + indentation + highlightSpaces(bLineUn, bg)));
+  }
+}; // jest --expand
+// Return formatted diff as joined string of all lines.
+
+const diffExpand = (aLinesUn, bLinesUn, aLinesIn, bLinesIn) => {
+  const isCommon = (aIndex, bIndex) => aLinesUn[aIndex] === bLinesUn[bIndex];
+
+  const array = [];
+
+  const put = line => {
+    array.push(line);
+  };
+
+  let aStart = 0;
+  let bStart = 0;
+
+  const foundSubsequence = (nCommon, aCommon, bCommon) => {
+    formatDelete(aStart, aCommon, aLinesUn, aLinesIn, put);
+    formatInsert(bStart, bCommon, bLinesUn, bLinesIn, put);
+    formatCommon(nCommon, aCommon, bCommon, aLinesIn, bLinesUn, bLinesIn, put);
+    aStart = aCommon + nCommon;
+    bStart = bCommon + nCommon;
+  };
+
+  const aLength = aLinesUn.length;
+  const bLength = bLinesUn.length;
+  (0, _diffSequences.default)(aLength, bLength, isCommon, foundSubsequence); // After the last common subsequence, format remaining change lines.
+
+  formatDelete(aStart, aLength, aLinesUn, aLinesIn, put);
+  formatInsert(bStart, bLength, bLinesUn, bLinesIn, put);
+  return array.join('\n');
+};
+
+const getContextLines = options =>
+  options &&
+  typeof options.contextLines === 'number' &&
+  options.contextLines >= 0
+    ? options.contextLines
+    : DIFF_CONTEXT_DEFAULT; // jest --no-expand
+// Return joined string of formatted diff for all change lines,
+// but if some common lines are omitted because there are more than the context,
+// then a “patch mark” precedes each set of adjacent changed and common lines.
+
+const diffNoExpand = (
+  aLinesUn,
+  bLinesUn,
+  aLinesIn,
+  bLinesIn,
+  nContextLines
+) => {
+  const isCommon = (aIndex, bIndex) => aLinesUn[aIndex] === bLinesUn[bIndex];
+
+  let iPatchMark = 0; // index of placeholder line for patch mark
+
+  const array = [''];
+
+  const put = line => {
+    array.push(line);
+  };
+
+  let isAtEnd = false;
+  const aLength = aLinesUn.length;
+  const bLength = bLinesUn.length;
+  const nContextLines2 = nContextLines + nContextLines; // Initialize the first patch for changes at the start,
+  // especially for edge case in which there is no common subsequence.
+
+  let aStart = 0;
+  let aEnd = 0;
+  let bStart = 0;
+  let bEnd = 0; // Given the number of items and starting indexes of each common subsequence,
+  // format any preceding change lines, and then common context lines.
+
+  const foundSubsequence = (nCommon, aStartCommon, bStartCommon) => {
+    const aEndCommon = aStartCommon + nCommon;
+    const bEndCommon = bStartCommon + nCommon;
+    isAtEnd = aEndCommon === aLength && bEndCommon === bLength; // If common subsequence is at start, re-initialize the first patch.
+
+    if (aStartCommon === 0 && bStartCommon === 0) {
+      const nLines = nContextLines < nCommon ? nContextLines : nCommon;
+      aStart = aEndCommon - nLines;
+      bStart = bEndCommon - nLines;
+      formatCommon(nLines, aStart, bStart, aLinesIn, bLinesUn, bLinesIn, put);
+      aEnd = aEndCommon;
+      bEnd = bEndCommon;
+      return;
+    } // Format preceding change lines.
+
+    formatDelete(aEnd, aStartCommon, aLinesUn, aLinesIn, put);
+    formatInsert(bEnd, bStartCommon, bLinesUn, bLinesIn, put);
+    aEnd = aStartCommon;
+    bEnd = bStartCommon; // If common subsequence is at end, then context follows preceding changes;
+    // else context follows preceding changes AND precedes following changes.
+
+    const maxContextLines = isAtEnd ? nContextLines : nContextLines2;
+
+    if (nCommon <= maxContextLines) {
+      // The patch includes all lines in the common subsequence.
+      formatCommon(nCommon, aEnd, bEnd, aLinesIn, bLinesUn, bLinesIn, put);
+      aEnd += nCommon;
+      bEnd += nCommon;
+      return;
+    } // The patch ends because context is less than number of common lines.
+
+    formatCommon(nContextLines, aEnd, bEnd, aLinesIn, bLinesUn, bLinesIn, put);
+    aEnd += nContextLines;
+    bEnd += nContextLines;
+    array[iPatchMark] = (0, _printDiffs.createPatchMark)(
+      aStart,
+      aEnd,
+      bStart,
+      bEnd
+    ); // If common subsequence is not at end, another patch follows it.
+
+    if (!isAtEnd) {
+      iPatchMark = array.length; // index of placeholder line
+
+      array[iPatchMark] = '';
+      const nLines = nContextLines < nCommon ? nContextLines : nCommon;
+      aStart = aEndCommon - nLines;
+      bStart = bEndCommon - nLines;
+      formatCommon(nLines, aStart, bStart, aLinesIn, bLinesUn, bLinesIn, put);
+      aEnd = aEndCommon;
+      bEnd = bEndCommon;
+    }
+  };
+
+  (0, _diffSequences.default)(aLength, bLength, isCommon, foundSubsequence); // If no common subsequence or last was not at end, format remaining change lines.
+
+  if (!isAtEnd) {
+    formatDelete(aEnd, aLength, aLinesUn, aLinesIn, put);
+    formatInsert(bEnd, bLength, bLinesUn, bLinesIn, put);
+    aEnd = aLength;
+    bEnd = bLength;
+  }
+
+  if (aStart === 0 && aEnd === aLength && bStart === 0 && bEnd === bLength) {
+    array.splice(0, 1); // delete placeholder line for patch mark
+  } else {
+    array[iPatchMark] = (0, _printDiffs.createPatchMark)(
+      aStart,
+      aEnd,
+      bStart,
+      bEnd
+    );
+  }
+
+  return array.join('\n');
+};
+
+var _default = (a, b, options, original) => {
+  if (a === b) {
+    return _constants.NO_DIFF_MESSAGE;
+  }
+
+  let aLinesUn = a.split('\n');
+  let bLinesUn = b.split('\n'); // Indentation is unknown if expected value is snapshot or multiline string.
+
+  let aLinesIn = aLinesUn;
+  let bLinesIn = bLinesUn;
+
+  if (original) {
+    // Indentation is known if expected value is data structure:
+    // Compare lines without indentation and format lines with indentation.
+    aLinesIn = original.a.split('\n');
+    bLinesIn = original.b.split('\n');
+
+    if (
+      aLinesUn.length !== aLinesIn.length ||
+      bLinesUn.length !== bLinesIn.length
+    ) {
+      // Fall back if unindented and indented lines are inconsistent.
+      aLinesUn = aLinesIn;
+      bLinesUn = bLinesIn;
+    }
+  }
+
+  return (
+    (0, _printDiffs.printAnnotation)(options) +
+    (options && options.expand === false
+      ? diffNoExpand(
+          aLinesUn,
+          bLinesUn,
+          aLinesIn,
+          bLinesIn,
+          getContextLines(options)
+        )
+      : diffExpand(aLinesUn, bLinesUn, aLinesIn, bLinesIn))
+  );
+};
+
+exports.default = _default;

node_modules/jest-diff/build/diffStrings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Diff } from './cleanupSemantic';
+declare const diffStrings: (a: string, b: string) => Diff[];
+export default diffStrings;
+//# sourceMappingURL=diffStrings.d.ts.map

node_modules/jest-diff/build/diffStrings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffStrings.d.ts","sourceRoot":"","sources":["../src/diffStrings.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAC,IAAI,EAAuC,MAAM,mBAAmB,CAAC;AAE7E,QAAA,MAAM,WAAW,kCAmChB,CAAC;AAEF,eAAe,WAAW,CAAC"}

node_modules/jest-diff/build/diffStrings.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _diffSequences = _interopRequireDefault(require('diff-sequences'));
+
+var _cleanupSemantic = require('./cleanupSemantic');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const diffStrings = (a, b) => {
+  const isCommon = (aIndex, bIndex) => a[aIndex] === b[bIndex];
+
+  let aIndex = 0;
+  let bIndex = 0;
+  const diffs = [];
+
+  const foundSubsequence = (nCommon, aCommon, bCommon) => {
+    if (aIndex !== aCommon) {
+      diffs.push(
+        new _cleanupSemantic.Diff(
+          _cleanupSemantic.DIFF_DELETE,
+          a.slice(aIndex, aCommon)
+        )
+      );
+    }
+
+    if (bIndex !== bCommon) {
+      diffs.push(
+        new _cleanupSemantic.Diff(
+          _cleanupSemantic.DIFF_INSERT,
+          b.slice(bIndex, bCommon)
+        )
+      );
+    }
+
+    aIndex = aCommon + nCommon; // number of characters compared in a
+
+    bIndex = bCommon + nCommon; // number of characters compared in b
+
+    diffs.push(
+      new _cleanupSemantic.Diff(
+        _cleanupSemantic.DIFF_EQUAL,
+        b.slice(bCommon, bIndex)
+      )
+    );
+  };
+
+  (0, _diffSequences.default)(a.length, b.length, isCommon, foundSubsequence); // After the last common subsequence, push remaining change items.
+
+  if (aIndex !== a.length) {
+    diffs.push(
+      new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_DELETE, a.slice(aIndex))
+    );
+  }
+
+  if (bIndex !== b.length) {
+    diffs.push(
+      new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_INSERT, b.slice(bIndex))
+    );
+  }
+
+  return diffs;
+};
+
+var _default = diffStrings;
+exports.default = _default;

node_modules/jest-diff/build/getAlignedDiffs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Diff } from './cleanupSemantic';
+declare const getAlignedDiffs: (diffs: Diff[]) => Diff[];
+export default getAlignedDiffs;
+//# sourceMappingURL=getAlignedDiffs.d.ts.map

node_modules/jest-diff/build/getAlignedDiffs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAlignedDiffs.d.ts","sourceRoot":"","sources":["../src/getAlignedDiffs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAC,IAAI,EAA2B,MAAM,mBAAmB,CAAC;AAuKjE,QAAA,MAAM,eAAe,2BAqBpB,CAAC;AAEF,eAAe,eAAe,CAAC"}

node_modules/jest-diff/build/getAlignedDiffs.js

@@ -0,0 +1,215 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+var _cleanupSemantic = require('./cleanupSemantic');
+
+var _printDiffs = require('./printDiffs');
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+// Encapsulate change lines until either a common newline or the end.
+class ChangeBuffer {
+  // incomplete line
+  // complete lines
+  constructor(op) {
+    _defineProperty(this, 'op', void 0);
+
+    _defineProperty(this, 'line', void 0);
+
+    _defineProperty(this, 'lines', void 0);
+
+    this.op = op;
+    this.line = [];
+    this.lines = [];
+  }
+
+  pushSubstring(substring) {
+    this.pushDiff(new _cleanupSemantic.Diff(this.op, substring));
+  }
+
+  pushLine() {
+    // Assume call only if line has at least one diff,
+    // therefore an empty line must have a diff which has an empty string.
+    this.lines.push(
+      new _cleanupSemantic.Diff(
+        this.op,
+        (0, _printDiffs.getHighlightedString)(this.op, this.line)
+      )
+    );
+    this.line.length = 0;
+  }
+
+  isLineEmpty() {
+    return this.line.length === 0;
+  } // Minor input to buffer.
+
+  pushDiff(diff) {
+    this.line.push(diff);
+  } // Main input to buffer.
+
+  align(diff) {
+    const string = diff[1];
+
+    if (_printDiffs.MULTILINE_REGEXP.test(string)) {
+      const substrings = string.split('\n');
+      const iLast = substrings.length - 1;
+      substrings.forEach((substring, i) => {
+        if (i < iLast) {
+          // The first substring completes the current change line.
+          // A middle substring is a change line.
+          this.pushSubstring(substring);
+          this.pushLine();
+        } else if (substring.length !== 0) {
+          // The last substring starts a change line, if it is not empty.
+          // Important: This non-empty condition also automatically omits
+          // the newline appended to the end of expected and received strings.
+          this.pushSubstring(substring);
+        }
+      });
+    } else {
+      // Append non-multiline string to current change line.
+      this.pushDiff(diff);
+    }
+  } // Output from buffer.
+
+  moveLinesTo(lines) {
+    if (!this.isLineEmpty()) {
+      this.pushLine();
+    }
+
+    lines.push(...this.lines);
+    this.lines.length = 0;
+  }
+} // Encapsulate common and change lines.
+
+class CommonBuffer {
+  constructor(deleteBuffer, insertBuffer) {
+    _defineProperty(this, 'deleteBuffer', void 0);
+
+    _defineProperty(this, 'insertBuffer', void 0);
+
+    _defineProperty(this, 'lines', void 0);
+
+    this.deleteBuffer = deleteBuffer;
+    this.insertBuffer = insertBuffer;
+    this.lines = [];
+  }
+
+  pushDiffCommonLine(diff) {
+    this.lines.push(diff);
+  }
+
+  pushDiffChangeLines(diff) {
+    const isDiffEmpty = diff[1].length === 0; // An empty diff string is redundant, unless a change line is empty.
+
+    if (!isDiffEmpty || this.deleteBuffer.isLineEmpty()) {
+      this.deleteBuffer.pushDiff(diff);
+    }
+
+    if (!isDiffEmpty || this.insertBuffer.isLineEmpty()) {
+      this.insertBuffer.pushDiff(diff);
+    }
+  }
+
+  flushChangeLines() {
+    this.deleteBuffer.moveLinesTo(this.lines);
+    this.insertBuffer.moveLinesTo(this.lines);
+  } // Input to buffer.
+
+  align(diff) {
+    const op = diff[0];
+    const string = diff[1];
+
+    if (_printDiffs.MULTILINE_REGEXP.test(string)) {
+      const substrings = string.split('\n');
+      const iLast = substrings.length - 1;
+      substrings.forEach((substring, i) => {
+        if (i === 0) {
+          const subdiff = new _cleanupSemantic.Diff(op, substring);
+
+          if (
+            this.deleteBuffer.isLineEmpty() &&
+            this.insertBuffer.isLineEmpty()
+          ) {
+            // If both current change lines are empty,
+            // then the first substring is a common line.
+            this.flushChangeLines();
+            this.pushDiffCommonLine(subdiff);
+          } else {
+            // If either current change line is non-empty,
+            // then the first substring completes the change lines.
+            this.pushDiffChangeLines(subdiff);
+            this.flushChangeLines();
+          }
+        } else if (i < iLast) {
+          // A middle substring is a common line.
+          this.pushDiffCommonLine(new _cleanupSemantic.Diff(op, substring));
+        } else if (substring.length !== 0) {
+          // The last substring starts a change line, if it is not empty.
+          // Important: This non-empty condition also automatically omits
+          // the newline appended to the end of expected and received strings.
+          this.pushDiffChangeLines(new _cleanupSemantic.Diff(op, substring));
+        }
+      });
+    } else {
+      // Append non-multiline string to current change lines.
+      // Important: It cannot be at the end following empty change lines,
+      // because newline appended to the end of expected and received strings.
+      this.pushDiffChangeLines(diff);
+    }
+  } // Output from buffer.
+
+  getLines() {
+    this.flushChangeLines();
+    return this.lines;
+  }
+} // Given diffs from expected and received strings,
+// return new array of diffs split or joined into lines.
+//
+// To correctly align a change line at the end, the algorithm:
+// * assumes that a newline was appended to the strings
+// * omits the last newline from the output array
+//
+// Assume the function is not called:
+// * if either expected or received is empty string
+// * if neither expected nor received is multiline string
+
+const getAlignedDiffs = diffs => {
+  const deleteBuffer = new ChangeBuffer(_cleanupSemantic.DIFF_DELETE);
+  const insertBuffer = new ChangeBuffer(_cleanupSemantic.DIFF_INSERT);
+  const commonBuffer = new CommonBuffer(deleteBuffer, insertBuffer);
+  diffs.forEach(diff => {
+    switch (diff[0]) {
+      case _cleanupSemantic.DIFF_DELETE:
+        deleteBuffer.align(diff);
+        break;
+
+      case _cleanupSemantic.DIFF_INSERT:
+        insertBuffer.align(diff);
+        break;
+
+      default:
+        commonBuffer.align(diff);
+    }
+  });
+  return commonBuffer.getLines();
+};
+
+var _default = getAlignedDiffs;
+exports.default = _default;

node_modules/jest-diff/build/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { DiffOptions as JestDiffOptions } from './types';
+declare function diff(a: any, b: any, options?: JestDiffOptions): string | null;
+declare namespace diff {
+    var getStringDiff: (expected: string, received: string, options?: JestDiffOptions | undefined) => {
+        isMultiline: true;
+        annotatedDiff: string;
+    } | {
+        isMultiline: false;
+        a: string;
+        b: string;
+    } | null;
+}
+declare namespace diff {
+    type DiffOptions = JestDiffOptions;
+}
+export = diff;
+//# sourceMappingURL=index.d.ts.map

node_modules/jest-diff/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,EAAC,WAAW,IAAI,eAAe,EAAC,MAAM,SAAS,CAAC;AAgCvD,iBAAS,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAgDtE;kBAhDQ,IAAI;;;;;;;;;;AAiHb,kBAAU,IAAI,CAAC;IACb,KAAY,WAAW,GAAG,eAAe,CAAC;CAC3C;AAID,SAAS,IAAI,CAAC"}

node_modules/jest-diff/build/index.js

@@ -0,0 +1,199 @@
+'use strict';
+
+var _prettyFormat = _interopRequireDefault(require('pretty-format'));
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _jestGetType = _interopRequireDefault(require('jest-get-type'));
+
+var _diffLines = _interopRequireDefault(require('./diffLines'));
+
+var _printDiffs = require('./printDiffs');
+
+var _constants = require('./constants');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(
+        Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        })
+      );
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    });
+  }
+  return target;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+const _prettyFormat$plugins = _prettyFormat.default.plugins,
+  AsymmetricMatcher = _prettyFormat$plugins.AsymmetricMatcher,
+  DOMCollection = _prettyFormat$plugins.DOMCollection,
+  DOMElement = _prettyFormat$plugins.DOMElement,
+  Immutable = _prettyFormat$plugins.Immutable,
+  ReactElement = _prettyFormat$plugins.ReactElement,
+  ReactTestComponent = _prettyFormat$plugins.ReactTestComponent;
+const PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+const FORMAT_OPTIONS = {
+  plugins: PLUGINS
+};
+
+const FORMAT_OPTIONS_0 = _objectSpread({}, FORMAT_OPTIONS, {
+  indent: 0
+});
+
+const FALLBACK_FORMAT_OPTIONS = {
+  callToJSON: false,
+  maxDepth: 10,
+  plugins: PLUGINS
+};
+
+const FALLBACK_FORMAT_OPTIONS_0 = _objectSpread({}, FALLBACK_FORMAT_OPTIONS, {
+  indent: 0
+}); // Generate a string that will highlight the difference between two values
+// with green and red. (similar to how github does code diffing)
+
+function diff(a, b, options) {
+  if (Object.is(a, b)) {
+    return _constants.NO_DIFF_MESSAGE;
+  }
+
+  const aType = (0, _jestGetType.default)(a);
+  let expectedType = aType;
+  let omitDifference = false;
+
+  if (aType === 'object' && typeof a.asymmetricMatch === 'function') {
+    if (a.$$typeof !== Symbol.for('jest.asymmetricMatcher')) {
+      // Do not know expected type of user-defined asymmetric matcher.
+      return null;
+    }
+
+    if (typeof a.getExpectedType !== 'function') {
+      // For example, expect.anything() matches either null or undefined
+      return null;
+    }
+
+    expectedType = a.getExpectedType(); // Primitive types boolean and number omit difference below.
+    // For example, omit difference for expect.stringMatching(regexp)
+
+    omitDifference = expectedType === 'string';
+  }
+
+  if (expectedType !== (0, _jestGetType.default)(b)) {
+    return (
+      '  Comparing two different types of values.' +
+      ` Expected ${_chalk.default.green(expectedType)} but ` +
+      `received ${_chalk.default.red((0, _jestGetType.default)(b))}.`
+    );
+  }
+
+  if (omitDifference) {
+    return null;
+  }
+
+  switch (aType) {
+    case 'string':
+      return (0, _diffLines.default)(a, b, options);
+
+    case 'boolean':
+    case 'number':
+      return comparePrimitive(a, b, options);
+
+    case 'map':
+      return compareObjects(sortMap(a), sortMap(b), options);
+
+    case 'set':
+      return compareObjects(sortSet(a), sortSet(b), options);
+
+    default:
+      return compareObjects(a, b, options);
+  }
+}
+
+function comparePrimitive(a, b, options) {
+  return (0, _diffLines.default)(
+    (0, _prettyFormat.default)(a, FORMAT_OPTIONS),
+    (0, _prettyFormat.default)(b, FORMAT_OPTIONS),
+    options
+  );
+}
+
+function sortMap(map) {
+  return new Map(Array.from(map.entries()).sort());
+}
+
+function sortSet(set) {
+  return new Set(Array.from(set.values()).sort());
+}
+
+function compareObjects(a, b, options) {
+  let diffMessage;
+  let hasThrown = false;
+
+  try {
+    diffMessage = (0, _diffLines.default)(
+      (0, _prettyFormat.default)(a, FORMAT_OPTIONS_0),
+      (0, _prettyFormat.default)(b, FORMAT_OPTIONS_0),
+      options,
+      {
+        a: (0, _prettyFormat.default)(a, FORMAT_OPTIONS),
+        b: (0, _prettyFormat.default)(b, FORMAT_OPTIONS)
+      }
+    );
+  } catch (e) {
+    hasThrown = true;
+  } // If the comparison yields no results, compare again but this time
+  // without calling `toJSON`. It's also possible that toJSON might throw.
+
+  if (!diffMessage || diffMessage === _constants.NO_DIFF_MESSAGE) {
+    diffMessage = (0, _diffLines.default)(
+      (0, _prettyFormat.default)(a, FALLBACK_FORMAT_OPTIONS_0),
+      (0, _prettyFormat.default)(b, FALLBACK_FORMAT_OPTIONS_0),
+      options,
+      {
+        a: (0, _prettyFormat.default)(a, FALLBACK_FORMAT_OPTIONS),
+        b: (0, _prettyFormat.default)(b, FALLBACK_FORMAT_OPTIONS)
+      }
+    );
+
+    if (diffMessage !== _constants.NO_DIFF_MESSAGE && !hasThrown) {
+      diffMessage = _constants.SIMILAR_MESSAGE + '\n\n' + diffMessage;
+    }
+  }
+
+  return diffMessage;
+} // eslint-disable-next-line no-redeclare
+
+diff.getStringDiff = _printDiffs.getStringDiff;
+module.exports = diff;

node_modules/jest-diff/build/joinAlignedDiffs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Diff } from './cleanupSemantic';
+export declare const joinAlignedDiffsNoExpand: (diffs: Diff[], nContextLines?: number) => string;
+export declare const joinAlignedDiffsExpand: (diffs: Diff[]) => string;
+//# sourceMappingURL=joinAlignedDiffs.d.ts.map

node_modules/jest-diff/build/joinAlignedDiffs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joinAlignedDiffs.d.ts","sourceRoot":"","sources":["../src/joinAlignedDiffs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAuC,IAAI,EAAC,MAAM,mBAAmB,CAAC;AAc7E,eAAO,MAAM,wBAAwB,mDAkKpC,CAAC;AAMF,eAAO,MAAM,sBAAsB,2BAgBpB,CAAC"}

node_modules/jest-diff/build/joinAlignedDiffs.js

@@ -0,0 +1,231 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.joinAlignedDiffsExpand = exports.joinAlignedDiffsNoExpand = void 0;
+
+var _cleanupSemantic = require('./cleanupSemantic');
+
+var _printDiffs = require('./printDiffs');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const DIFF_CONTEXT_DEFAULT = 5; // same as diffLines
+// jest --no-expand
+//
+// Given array of aligned strings with inverse highlight formatting,
+// return joined lines with diff formatting (and patch marks, if needed).
+
+const joinAlignedDiffsNoExpand = (
+  diffs,
+  nContextLines = DIFF_CONTEXT_DEFAULT
+) => {
+  const iLength = diffs.length;
+  const nContextLines2 = nContextLines + nContextLines; // First pass: count output lines and see if it has patches.
+
+  let jLength = iLength;
+  let hasExcessAtStartOrEnd = false;
+  let nExcessesBetweenChanges = 0;
+  let i = 0;
+
+  while (i !== iLength) {
+    const iStart = i;
+
+    while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_EQUAL) {
+      i += 1;
+    }
+
+    if (iStart !== i) {
+      if (iStart === 0) {
+        // at start
+        if (i > nContextLines) {
+          jLength -= i - nContextLines; // subtract excess common lines
+
+          hasExcessAtStartOrEnd = true;
+        }
+      } else if (i === iLength) {
+        // at end
+        const n = i - iStart;
+
+        if (n > nContextLines) {
+          jLength -= n - nContextLines; // subtract excess common lines
+
+          hasExcessAtStartOrEnd = true;
+        }
+      } else {
+        // between changes
+        const n = i - iStart;
+
+        if (n > nContextLines2) {
+          jLength -= n - nContextLines2; // subtract excess common lines
+
+          nExcessesBetweenChanges += 1;
+        }
+      }
+    }
+
+    while (i !== iLength && diffs[i][0] !== _cleanupSemantic.DIFF_EQUAL) {
+      i += 1;
+    }
+  }
+
+  const hasPatch = nExcessesBetweenChanges !== 0 || hasExcessAtStartOrEnd;
+
+  if (nExcessesBetweenChanges !== 0) {
+    jLength += nExcessesBetweenChanges + 1; // add patch lines
+  } else if (hasExcessAtStartOrEnd) {
+    jLength += 1; // add patch line
+  }
+
+  const jLast = jLength - 1;
+  const lines = [];
+  let jPatchMark = 0; // index of placeholder line for current patch mark
+
+  if (hasPatch) {
+    lines.push(''); // placeholder line for first patch mark
+  } // Indexes of expected or received lines in current patch:
+
+  let aStart = 0;
+  let bStart = 0;
+  let aEnd = 0;
+  let bEnd = 0;
+
+  const pushCommonLine = line => {
+    const j = lines.length;
+    lines.push((0, _printDiffs.printCommonLine)(line, j === 0 || j === jLast));
+    aEnd += 1;
+    bEnd += 1;
+  };
+
+  const pushDeleteLine = line => {
+    lines.push((0, _printDiffs.printDeleteLine)(line));
+    aEnd += 1;
+  };
+
+  const pushInsertLine = line => {
+    lines.push((0, _printDiffs.printInsertLine)(line));
+    bEnd += 1;
+  }; // Second pass: push lines with diff formatting (and patch marks, if needed).
+
+  i = 0;
+
+  while (i !== iLength) {
+    let iStart = i;
+
+    while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_EQUAL) {
+      i += 1;
+    }
+
+    if (iStart !== i) {
+      if (iStart === 0) {
+        // at beginning
+        if (i > nContextLines) {
+          iStart = i - nContextLines;
+          aStart = iStart;
+          bStart = iStart;
+          aEnd = aStart;
+          bEnd = bStart;
+        }
+
+        for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
+          pushCommonLine(diffs[iCommon][1]);
+        }
+      } else if (i === iLength) {
+        // at end
+        const iEnd = i - iStart > nContextLines ? iStart + nContextLines : i;
+
+        for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
+          pushCommonLine(diffs[iCommon][1]);
+        }
+      } else {
+        // between changes
+        const nCommon = i - iStart;
+
+        if (nCommon > nContextLines2) {
+          const iEnd = iStart + nContextLines;
+
+          for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
+            pushCommonLine(diffs[iCommon][1]);
+          }
+
+          lines[jPatchMark] = (0, _printDiffs.createPatchMark)(
+            aStart,
+            aEnd,
+            bStart,
+            bEnd
+          );
+          jPatchMark = lines.length;
+          lines.push(''); // placeholder line for next patch mark
+
+          const nOmit = nCommon - nContextLines2;
+          aStart = aEnd + nOmit;
+          bStart = bEnd + nOmit;
+          aEnd = aStart;
+          bEnd = bStart;
+
+          for (let iCommon = i - nContextLines; iCommon !== i; iCommon += 1) {
+            pushCommonLine(diffs[iCommon][1]);
+          }
+        } else {
+          for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
+            pushCommonLine(diffs[iCommon][1]);
+          }
+        }
+      }
+    }
+
+    while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_DELETE) {
+      pushDeleteLine(diffs[i][1]);
+      i += 1;
+    }
+
+    while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_INSERT) {
+      pushInsertLine(diffs[i][1]);
+      i += 1;
+    }
+  }
+
+  if (hasPatch) {
+    lines[jPatchMark] = (0, _printDiffs.createPatchMark)(
+      aStart,
+      aEnd,
+      bStart,
+      bEnd
+    );
+  }
+
+  return lines.join('\n');
+}; // jest --expand
+//
+// Given array of aligned strings with inverse highlight formatting,
+// return joined lines with diff formatting.
+
+exports.joinAlignedDiffsNoExpand = joinAlignedDiffsNoExpand;
+
+const joinAlignedDiffsExpand = diffs =>
+  diffs
+    .map((diff, i, diffs) => {
+      const line = diff[1];
+
+      switch (diff[0]) {
+        case _cleanupSemantic.DIFF_DELETE:
+          return (0, _printDiffs.printDeleteLine)(line);
+
+        case _cleanupSemantic.DIFF_INSERT:
+          return (0, _printDiffs.printInsertLine)(line);
+
+        default:
+          return (0, _printDiffs.printCommonLine)(
+            line,
+            i === 0 || i === diffs.length - 1
+          );
+      }
+    })
+    .join('\n');
+
+exports.joinAlignedDiffsExpand = joinAlignedDiffsExpand;

node_modules/jest-diff/build/printDiffs.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Diff } from './cleanupSemantic';
+import { DiffOptions } from './types';
+export declare const DIM_COLOR: import("chalk").Chalk & {
+    supportsColor: import("chalk").ColorSupport;
+};
+export declare const EXPECTED_COLOR: import("chalk").Chalk & {
+    supportsColor: import("chalk").ColorSupport;
+};
+export declare const INVERTED_COLOR: import("chalk").Chalk & {
+    supportsColor: import("chalk").ColorSupport;
+};
+export declare const RECEIVED_COLOR: import("chalk").Chalk & {
+    supportsColor: import("chalk").ColorSupport;
+};
+export declare const getHighlightedString: (op: number, diffs: Diff[]) => string;
+export declare const getExpectedString: (diffs: Diff[]) => string;
+export declare const getReceivedString: (diffs: Diff[]) => string;
+export declare const MULTILINE_REGEXP: RegExp;
+export declare const printDeleteLine: (line: string) => string;
+export declare const printInsertLine: (line: string) => string;
+export declare const printCommonLine: (line: string, isFirstOrLast?: boolean) => string;
+export declare const computeStringDiffs: (expected: string, received: string) => {
+    diffs: Diff[];
+    isMultiline: boolean;
+};
+export declare const hasCommonDiff: (diffs: Diff[], isMultiline: boolean) => boolean;
+export declare const printAnnotation: (options?: DiffOptions | undefined) => string;
+export declare const createPatchMark: (aStart: number, aEnd: number, bStart: number, bEnd: number) => string;
+export declare const printMultilineStringDiffs: (diffs: Diff[], expand: boolean) => string;
+declare type StringDiffResult = {
+    isMultiline: true;
+    annotatedDiff: string;
+} | {
+    isMultiline: false;
+    a: string;
+    b: string;
+} | null;
+export declare const getStringDiff: (expected: string, received: string, options?: DiffOptions | undefined) => StringDiffResult;
+export {};
+//# sourceMappingURL=printDiffs.d.ts.map

node_modules/jest-diff/build/printDiffs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printDiffs.d.ts","sourceRoot":"","sources":["../src/printDiffs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAKL,IAAI,EACL,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAC,WAAW,EAAC,MAAM,SAAS,CAAC;AAEpC,eAAO,MAAM,SAAS;;CAAY,CAAC;AACnC,eAAO,MAAM,cAAc;;CAAc,CAAC;AAC1C,eAAO,MAAM,cAAc;;CAAgB,CAAC;AAC5C,eAAO,MAAM,cAAc;;CAAY,CAAC;AAOxC,eAAO,MAAM,oBAAoB,uCAU9B,CAAC;AAEJ,eAAO,MAAM,iBAAiB,2BACY,CAAC;AAE3C,eAAO,MAAM,iBAAiB,2BACY,CAAC;AAE3C,eAAO,MAAM,gBAAgB,QAAO,CAAC;AAUrC,eAAO,MAAM,eAAe,0BAC+C,CAAC;AAE5E,eAAO,MAAM,eAAe,0BAC+C,CAAC;AAG5E,eAAO,MAAM,eAAe,mDAKpB,CAAC;AAET,eAAO,MAAM,kBAAkB;;;CAc9B,CAAC;AAEF,eAAO,MAAM,aAAa,kDAUzB,CAAC;AAEF,eAAO,MAAM,eAAe,+CAIpB,CAAC;AAGT,eAAO,MAAM,eAAe,wEAQzB,CAAC;AAGJ,eAAO,MAAM,yBAAyB,4CAQrC,CAAC;AAIF,aAAK,gBAAgB,GACjB;IAAC,WAAW,EAAE,IAAI,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC,GAC1C;IAAC,WAAW,EAAE,KAAK,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,GAC1C,IAAI,CAAC;AAOT,eAAO,MAAM,aAAa,6FAoCzB,CAAC"}

node_modules/jest-diff/build/printDiffs.js

@@ -0,0 +1,196 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.getStringDiff = exports.printMultilineStringDiffs = exports.createPatchMark = exports.printAnnotation = exports.hasCommonDiff = exports.computeStringDiffs = exports.printCommonLine = exports.printInsertLine = exports.printDeleteLine = exports.MULTILINE_REGEXP = exports.getReceivedString = exports.getExpectedString = exports.getHighlightedString = exports.RECEIVED_COLOR = exports.INVERTED_COLOR = exports.EXPECTED_COLOR = exports.DIM_COLOR = void 0;
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _cleanupSemantic = require('./cleanupSemantic');
+
+var _diffStrings = _interopRequireDefault(require('./diffStrings'));
+
+var _getAlignedDiffs = _interopRequireDefault(require('./getAlignedDiffs'));
+
+var _joinAlignedDiffs = require('./joinAlignedDiffs');
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const DIM_COLOR = _chalk.default.dim;
+exports.DIM_COLOR = DIM_COLOR;
+const EXPECTED_COLOR = _chalk.default.green;
+exports.EXPECTED_COLOR = EXPECTED_COLOR;
+const INVERTED_COLOR = _chalk.default.inverse;
+exports.INVERTED_COLOR = INVERTED_COLOR;
+const RECEIVED_COLOR = _chalk.default.red;
+exports.RECEIVED_COLOR = RECEIVED_COLOR;
+const PATCH_COLOR = _chalk.default.yellow; // Given change op and array of diffs, return concatenated string:
+// * include common strings
+// * include change strings which have argument op (inverse highlight)
+// * exclude change strings which have opposite op
+
+const getHighlightedString = (op, diffs) =>
+  diffs.reduce(
+    (reduced, diff) =>
+      reduced +
+      (diff[0] === _cleanupSemantic.DIFF_EQUAL
+        ? diff[1]
+        : diff[0] === op
+        ? INVERTED_COLOR(diff[1])
+        : ''),
+    ''
+  );
+
+exports.getHighlightedString = getHighlightedString;
+
+const getExpectedString = diffs =>
+  getHighlightedString(_cleanupSemantic.DIFF_DELETE, diffs);
+
+exports.getExpectedString = getExpectedString;
+
+const getReceivedString = diffs =>
+  getHighlightedString(_cleanupSemantic.DIFF_INSERT, diffs);
+
+exports.getReceivedString = getReceivedString;
+const MULTILINE_REGEXP = /\n/;
+exports.MULTILINE_REGEXP = MULTILINE_REGEXP;
+const NEWLINE_SYMBOL = '\u{21B5}'; // downwards arrow with corner leftwards
+
+const SPACE_SYMBOL = '\u{00B7}'; // middle dot
+// Instead of inverse highlight which now implies a change,
+// replace common spaces with middle dot at the end of the line.
+
+const replaceSpacesAtEnd = line =>
+  line.replace(/\s+$/, spaces => SPACE_SYMBOL.repeat(spaces.length));
+
+const printDeleteLine = line =>
+  EXPECTED_COLOR(line.length !== 0 ? '- ' + replaceSpacesAtEnd(line) : '-');
+
+exports.printDeleteLine = printDeleteLine;
+
+const printInsertLine = line =>
+  RECEIVED_COLOR(line.length !== 0 ? '+ ' + replaceSpacesAtEnd(line) : '+'); // Prevent visually ambiguous empty line as the first or the last.
+
+exports.printInsertLine = printInsertLine;
+
+const printCommonLine = (line, isFirstOrLast = false) =>
+  line.length !== 0
+    ? DIM_COLOR('  ' + replaceSpacesAtEnd(line))
+    : isFirstOrLast
+    ? DIM_COLOR('  ' + NEWLINE_SYMBOL)
+    : '';
+
+exports.printCommonLine = printCommonLine;
+
+const computeStringDiffs = (expected, received) => {
+  const isMultiline =
+    MULTILINE_REGEXP.test(expected) || MULTILINE_REGEXP.test(received); // getAlignedDiffs assumes that a newline was appended to the strings.
+
+  if (isMultiline) {
+    expected += '\n';
+    received += '\n';
+  }
+
+  const diffs = (0, _diffStrings.default)(expected, received);
+  (0, _cleanupSemantic.cleanupSemantic)(diffs); // impure function
+
+  return {
+    diffs,
+    isMultiline
+  };
+};
+
+exports.computeStringDiffs = computeStringDiffs;
+
+const hasCommonDiff = (diffs, isMultiline) => {
+  if (isMultiline) {
+    // Important: Ignore common newline that was appended to multiline strings!
+    const iLast = diffs.length - 1;
+    return diffs.some(
+      (diff, i) =>
+        diff[0] === _cleanupSemantic.DIFF_EQUAL &&
+        (i !== iLast || diff[1] !== '\n')
+    );
+  }
+
+  return diffs.some(diff => diff[0] === _cleanupSemantic.DIFF_EQUAL);
+};
+
+exports.hasCommonDiff = hasCommonDiff;
+
+const printAnnotation = options =>
+  EXPECTED_COLOR('- ' + ((options && options.aAnnotation) || 'Expected')) +
+  '\n' +
+  RECEIVED_COLOR('+ ' + ((options && options.bAnnotation) || 'Received')) +
+  '\n\n'; // In GNU diff format, indexes are one-based instead of zero-based.
+
+exports.printAnnotation = printAnnotation;
+
+const createPatchMark = (aStart, aEnd, bStart, bEnd) =>
+  PATCH_COLOR(
+    `@@ -${aStart + 1},${aEnd - aStart} +${bStart + 1},${bEnd - bStart} @@`
+  ); // Return formatted diff lines without labels.
+
+exports.createPatchMark = createPatchMark;
+
+const printMultilineStringDiffs = (diffs, expand) => {
+  const lines = (0, _getAlignedDiffs.default)(diffs);
+  return expand
+    ? (0, _joinAlignedDiffs.joinAlignedDiffsExpand)(lines)
+    : (0, _joinAlignedDiffs.joinAlignedDiffsNoExpand)(lines);
+};
+
+exports.printMultilineStringDiffs = printMultilineStringDiffs;
+const MAX_DIFF_STRING_LENGTH = 20000;
+
+// Print specific substring diff for strings only:
+// * if strings are not equal
+// * if neither string is empty
+// * if neither string is too long
+// * if there is a common string after semantic cleanup
+const getStringDiff = (expected, received, options) => {
+  if (
+    expected === received ||
+    expected.length === 0 ||
+    received.length === 0 ||
+    expected.length > MAX_DIFF_STRING_LENGTH ||
+    received.length > MAX_DIFF_STRING_LENGTH
+  ) {
+    return null;
+  }
+
+  const _computeStringDiffs = computeStringDiffs(expected, received),
+    diffs = _computeStringDiffs.diffs,
+    isMultiline = _computeStringDiffs.isMultiline;
+
+  if (!hasCommonDiff(diffs, isMultiline)) {
+    return null;
+  }
+
+  return isMultiline
+    ? {
+        annotatedDiff:
+          printAnnotation(options) +
+          printMultilineStringDiffs(
+            diffs,
+            options === undefined || options.expand !== false
+          ),
+        isMultiline
+      }
+    : {
+        a: getExpectedString(diffs),
+        b: getReceivedString(diffs),
+        isMultiline
+      };
+};
+
+exports.getStringDiff = getStringDiff;

node_modules/jest-diff/build/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare type DiffOptions = {
+    aAnnotation?: string;
+    bAnnotation?: string;
+    expand?: boolean;
+    contextLines?: number;
+};
+//# sourceMappingURL=types.d.ts.map

node_modules/jest-diff/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,oBAAY,WAAW,GAAG;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC"}

node_modules/jest-diff/build/types.js

@@ -0,0 +1 @@
+'use strict';