{"version":3,"file":"fast-diff-DNDSwfiB.js","sources":["../../../node_modules/fast-diff/diff.js"],"sourcesContent":["/**\n * This library modifies the diff-patch-match library by Neil Fraser\n * by removing the patch and match functionality and certain advanced\n * options in the diff function. The original license is as follows:\n *\n * ===\n *\n * Diff Match and Patch\n *\n * Copyright 2006 Google Inc.\n * http://code.google.com/p/google-diff-match-patch/\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * The data structure representing a diff is an array of tuples:\n * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\n * which means: delete 'Hello', add 'Goodbye' and keep ' world.'\n */\nvar DIFF_DELETE = -1;\nvar DIFF_INSERT = 1;\nvar DIFF_EQUAL = 0;\n\n\n/**\n * Find the differences between two texts.  Simplifies the problem by stripping\n * any common prefix or suffix off the texts before diffing.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {Int|Object} [cursor_pos] Edit position in text1 or object with more info\n * @return {Array} Array of diff tuples.\n */\nfunction diff_main(text1, text2, cursor_pos, _fix_unicode) {\n  // Check for equality\n  if (text1 === text2) {\n    if (text1) {\n      return [[DIFF_EQUAL, text1]];\n    }\n    return [];\n  }\n\n  if (cursor_pos != null) {\n    var editdiff = find_cursor_edit_diff(text1, text2, cursor_pos);\n    if (editdiff) {\n      return editdiff;\n    }\n  }\n\n  // Trim off common prefix (speedup).\n  var commonlength = diff_commonPrefix(text1, text2);\n  var commonprefix = text1.substring(0, commonlength);\n  text1 = text1.substring(commonlength);\n  text2 = text2.substring(commonlength);\n\n  // Trim off common suffix (speedup).\n  commonlength = diff_commonSuffix(text1, text2);\n  var commonsuffix = text1.substring(text1.length - commonlength);\n  text1 = text1.substring(0, text1.length - commonlength);\n  text2 = text2.substring(0, text2.length - commonlength);\n\n  // Compute the diff on the middle block.\n  var diffs = diff_compute_(text1, text2);\n\n  // Restore the prefix and suffix.\n  if (commonprefix) {\n    diffs.unshift([DIFF_EQUAL, commonprefix]);\n  }\n  if (commonsuffix) {\n    diffs.push([DIFF_EQUAL, commonsuffix]);\n  }\n  diff_cleanupMerge(diffs, _fix_unicode);\n  return diffs;\n};\n\n\n/**\n * Find the differences between two texts.  Assumes that the texts do not\n * have any common prefix or suffix.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_compute_(text1, text2) {\n  var diffs;\n\n  if (!text1) {\n    // Just add some text (speedup).\n    return [[DIFF_INSERT, text2]];\n  }\n\n  if (!text2) {\n    // Just delete some text (speedup).\n    return [[DIFF_DELETE, text1]];\n  }\n\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  var i = longtext.indexOf(shorttext);\n  if (i !== -1) {\n    // Shorter text is inside the longer text (speedup).\n    diffs = [\n      [DIFF_INSERT, longtext.substring(0, i)],\n      [DIFF_EQUAL, shorttext],\n      [DIFF_INSERT, longtext.substring(i + shorttext.length)]\n    ];\n    // Swap insertions for deletions if diff is reversed.\n    if (text1.length > text2.length) {\n      diffs[0][0] = diffs[2][0] = DIFF_DELETE;\n    }\n    return diffs;\n  }\n\n  if (shorttext.length === 1) {\n    // Single character string.\n    // After the previous speedup, the character can't be an equality.\n    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n  }\n\n  // Check to see if the problem can be split in two.\n  var hm = diff_halfMatch_(text1, text2);\n  if (hm) {\n    // A half-match was found, sort out the return data.\n    var text1_a = hm[0];\n    var text1_b = hm[1];\n    var text2_a = hm[2];\n    var text2_b = hm[3];\n    var mid_common = hm[4];\n    // Send both pairs off for separate processing.\n    var diffs_a = diff_main(text1_a, text2_a);\n    var diffs_b = diff_main(text1_b, text2_b);\n    // Merge the results.\n    return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);\n  }\n\n  return diff_bisect_(text1, text2);\n};\n\n\n/**\n * Find the 'middle snake' of a diff, split the problem in two\n * and return the recursively constructed diff.\n * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @return {Array} Array of diff tuples.\n * @private\n */\nfunction diff_bisect_(text1, text2) {\n  // Cache the text lengths to prevent multiple calls.\n  var text1_length = text1.length;\n  var text2_length = text2.length;\n  var max_d = Math.ceil((text1_length + text2_length) / 2);\n  var v_offset = max_d;\n  var v_length = 2 * max_d;\n  var v1 = new Array(v_length);\n  var v2 = new Array(v_length);\n  // Setting all elements to -1 is faster in Chrome & Firefox than mixing\n  // integers and undefined.\n  for (var x = 0; x < v_length; x++) {\n    v1[x] = -1;\n    v2[x] = -1;\n  }\n  v1[v_offset + 1] = 0;\n  v2[v_offset + 1] = 0;\n  var delta = text1_length - text2_length;\n  // If the total number of characters is odd, then the front path will collide\n  // with the reverse path.\n  var front = (delta % 2 !== 0);\n  // Offsets for start and end of k loop.\n  // Prevents mapping of space beyond the grid.\n  var k1start = 0;\n  var k1end = 0;\n  var k2start = 0;\n  var k2end = 0;\n  for (var d = 0; d < max_d; d++) {\n    // Walk the front path one step.\n    for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\n      var k1_offset = v_offset + k1;\n      var x1;\n      if (k1 === -d || (k1 !== d && v1[k1_offset - 1] < v1[k1_offset + 1])) {\n        x1 = v1[k1_offset + 1];\n      } else {\n        x1 = v1[k1_offset - 1] + 1;\n      }\n      var y1 = x1 - k1;\n      while (\n        x1 < text1_length && y1 < text2_length &&\n        text1.charAt(x1) === text2.charAt(y1)\n      ) {\n        x1++;\n        y1++;\n      }\n      v1[k1_offset] = x1;\n      if (x1 > text1_length) {\n        // Ran off the right of the graph.\n        k1end += 2;\n      } else if (y1 > text2_length) {\n        // Ran off the bottom of the graph.\n        k1start += 2;\n      } else if (front) {\n        var k2_offset = v_offset + delta - k1;\n        if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] !== -1) {\n          // Mirror x2 onto top-left coordinate system.\n          var x2 = text1_length - v2[k2_offset];\n          if (x1 >= x2) {\n            // Overlap detected.\n            return diff_bisectSplit_(text1, text2, x1, y1);\n          }\n        }\n      }\n    }\n\n    // Walk the reverse path one step.\n    for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\n      var k2_offset = v_offset + k2;\n      var x2;\n      if (k2 === -d || (k2 !== d && v2[k2_offset - 1] < v2[k2_offset + 1])) {\n        x2 = v2[k2_offset + 1];\n      } else {\n        x2 = v2[k2_offset - 1] + 1;\n      }\n      var y2 = x2 - k2;\n      while (\n        x2 < text1_length && y2 < text2_length &&\n        text1.charAt(text1_length - x2 - 1) === text2.charAt(text2_length - y2 - 1)\n      ) {\n        x2++;\n        y2++;\n      }\n      v2[k2_offset] = x2;\n      if (x2 > text1_length) {\n        // Ran off the left of the graph.\n        k2end += 2;\n      } else if (y2 > text2_length) {\n        // Ran off the top of the graph.\n        k2start += 2;\n      } else if (!front) {\n        var k1_offset = v_offset + delta - k2;\n        if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] !== -1) {\n          var x1 = v1[k1_offset];\n          var y1 = v_offset + x1 - k1_offset;\n          // Mirror x2 onto top-left coordinate system.\n          x2 = text1_length - x2;\n          if (x1 >= x2) {\n            // Overlap detected.\n            return diff_bisectSplit_(text1, text2, x1, y1);\n          }\n        }\n      }\n    }\n  }\n  // Diff took too long and hit the deadline or\n  // number of diffs equals number of characters, no commonality at all.\n  return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n};\n\n\n/**\n * Given the location of the 'middle snake', split the diff in two parts\n * and recurse.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} x Index of split point in text1.\n * @param {number} y Index of split point in text2.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_bisectSplit_(text1, text2, x, y) {\n  var text1a = text1.substring(0, x);\n  var text2a = text2.substring(0, y);\n  var text1b = text1.substring(x);\n  var text2b = text2.substring(y);\n\n  // Compute both diffs serially.\n  var diffs = diff_main(text1a, text2a);\n  var diffsb = diff_main(text1b, text2b);\n\n  return diffs.concat(diffsb);\n};\n\n\n/**\n * Determine the common prefix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the start of each\n *     string.\n */\nfunction diff_commonPrefix(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerstart = 0;\n  while (pointermin < pointermid) {\n    if (\n      text1.substring(pointerstart, pointermid) ==\n      text2.substring(pointerstart, pointermid)\n    ) {\n      pointermin = pointermid;\n      pointerstart = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n\n  if (is_surrogate_pair_start(text1.charCodeAt(pointermid - 1))) {\n    pointermid--;\n  }\n\n  return pointermid;\n};\n\n\n/**\n * Determine the common suffix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of each string.\n */\nfunction diff_commonSuffix(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 || text1.slice(-1) !== text2.slice(-1)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerend = 0;\n  while (pointermin < pointermid) {\n    if (\n      text1.substring(text1.length - pointermid, text1.length - pointerend) ==\n      text2.substring(text2.length - pointermid, text2.length - pointerend)\n    ) {\n      pointermin = pointermid;\n      pointerend = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n\n  if (is_surrogate_pair_end(text1.charCodeAt(text1.length - pointermid))) {\n    pointermid--;\n  }\n\n  return pointermid;\n};\n\n\n/**\n * Do the two texts share a substring which is at least half the length of the\n * longer text?\n * This speedup can produce non-minimal diffs.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {Array.<string>} Five element Array, containing the prefix of\n *     text1, the suffix of text1, the prefix of text2, the suffix of\n *     text2 and the common middle.  Or null if there was no match.\n */\nfunction diff_halfMatch_(text1, text2) {\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {\n    return null;  // Pointless.\n  }\n\n  /**\n   * Does a substring of shorttext exist within longtext such that the substring\n   * is at least half the length of longtext?\n   * Closure, but does not reference any external variables.\n   * @param {string} longtext Longer string.\n   * @param {string} shorttext Shorter string.\n   * @param {number} i Start index of quarter length substring within longtext.\n   * @return {Array.<string>} Five element Array, containing the prefix of\n   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix\n   *     of shorttext and the common middle.  Or null if there was no match.\n   * @private\n   */\n  function diff_halfMatchI_(longtext, shorttext, i) {\n    // Start with a 1/4 length substring at position i as a seed.\n    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\n    var j = -1;\n    var best_common = '';\n    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\n    while ((j = shorttext.indexOf(seed, j + 1)) !== -1) {\n      var prefixLength = diff_commonPrefix(\n        longtext.substring(i), shorttext.substring(j));\n      var suffixLength = diff_commonSuffix(\n        longtext.substring(0, i), shorttext.substring(0, j));\n      if (best_common.length < suffixLength + prefixLength) {\n        best_common = shorttext.substring(\n          j - suffixLength, j) + shorttext.substring(j, j + prefixLength);\n        best_longtext_a = longtext.substring(0, i - suffixLength);\n        best_longtext_b = longtext.substring(i + prefixLength);\n        best_shorttext_a = shorttext.substring(0, j - suffixLength);\n        best_shorttext_b = shorttext.substring(j + prefixLength);\n      }\n    }\n    if (best_common.length * 2 >= longtext.length) {\n      return [\n        best_longtext_a, best_longtext_b,\n        best_shorttext_a, best_shorttext_b, best_common\n      ];\n    } else {\n      return null;\n    }\n  }\n\n  // First check if the second quarter is the seed for a half-match.\n  var hm1 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 4));\n  // Check again based on the third quarter.\n  var hm2 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 2));\n  var hm;\n  if (!hm1 && !hm2) {\n    return null;\n  } else if (!hm2) {\n    hm = hm1;\n  } else if (!hm1) {\n    hm = hm2;\n  } else {\n    // Both matched.  Select the longest.\n    hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\n  }\n\n  // A half-match was found, sort out the return data.\n  var text1_a, text1_b, text2_a, text2_b;\n  if (text1.length > text2.length) {\n    text1_a = hm[0];\n    text1_b = hm[1];\n    text2_a = hm[2];\n    text2_b = hm[3];\n  } else {\n    text2_a = hm[0];\n    text2_b = hm[1];\n    text1_a = hm[2];\n    text1_b = hm[3];\n  }\n  var mid_common = hm[4];\n  return [text1_a, text1_b, text2_a, text2_b, mid_common];\n};\n\n\n/**\n * Reorder and merge like edit sections.  Merge equalities.\n * Any edit section can move as long as it doesn't cross an equality.\n * @param {Array} diffs Array of diff tuples.\n * @param {boolean} fix_unicode Whether to normalize to a unicode-correct diff\n */\nfunction diff_cleanupMerge(diffs, fix_unicode) {\n  diffs.push([DIFF_EQUAL, '']);  // Add a dummy entry at the end.\n  var pointer = 0;\n  var count_delete = 0;\n  var count_insert = 0;\n  var text_delete = '';\n  var text_insert = '';\n  var commonlength;\n  while (pointer < diffs.length) {\n    if (pointer < diffs.length - 1 && !diffs[pointer][1]) {\n      diffs.splice(pointer, 1);\n      continue;\n    }\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n\n        count_insert++;\n        text_insert += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_DELETE:\n        count_delete++;\n        text_delete += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_EQUAL:\n        var previous_equality = pointer - count_insert - count_delete - 1;\n        if (fix_unicode) {\n          // prevent splitting of unicode surrogate pairs.  when fix_unicode is true,\n          // we assume that the old and new text in the diff are complete and correct\n          // unicode-encoded JS strings, but the tuple boundaries may fall between\n          // surrogate pairs.  we fix this by shaving off stray surrogates from the end\n          // of the previous equality and the beginning of this equality.  this may create\n          // empty equalities or a common prefix or suffix.  for example, if AB and AC are\n          // emojis, `[[0, 'A'], [-1, 'BA'], [0, 'C']]` would turn into deleting 'ABAC' and\n          // inserting 'AC', and then the common suffix 'AC' will be eliminated.  in this\n          // particular case, both equalities go away, we absorb any previous inequalities,\n          // and we keep scanning for the next equality before rewriting the tuples.\n          if (previous_equality >= 0 && ends_with_pair_start(diffs[previous_equality][1])) {\n            var stray = diffs[previous_equality][1].slice(-1);\n            diffs[previous_equality][1] = diffs[previous_equality][1].slice(0, -1);\n            text_delete = stray + text_delete;\n            text_insert = stray + text_insert;\n            if (!diffs[previous_equality][1]) {\n              // emptied out previous equality, so delete it and include previous delete/insert\n              diffs.splice(previous_equality, 1);\n              pointer--;\n              var k = previous_equality - 1;\n              if (diffs[k] && diffs[k][0] === DIFF_INSERT) {\n                count_insert++;\n                text_insert = diffs[k][1] + text_insert;\n                k--;\n              }\n              if (diffs[k] && diffs[k][0] === DIFF_DELETE) {\n                count_delete++;\n                text_delete = diffs[k][1] + text_delete;\n                k--;\n              }\n              previous_equality = k;\n            }\n          }\n          if (starts_with_pair_end(diffs[pointer][1])) {\n            var stray = diffs[pointer][1].charAt(0);\n            diffs[pointer][1] = diffs[pointer][1].slice(1);\n            text_delete += stray;\n            text_insert += stray;\n          }\n        }\n        if (pointer < diffs.length - 1 && !diffs[pointer][1]) {\n          // for empty equality not at end, wait for next equality\n          diffs.splice(pointer, 1);\n          break;\n        }\n        if (text_delete.length > 0 || text_insert.length > 0) {\n          // note that diff_commonPrefix and diff_commonSuffix are unicode-aware\n          if (text_delete.length > 0 && text_insert.length > 0) {\n            // Factor out any common prefixes.\n            commonlength = diff_commonPrefix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              if (previous_equality >= 0) {\n                diffs[previous_equality][1] += text_insert.substring(0, commonlength);\n              } else {\n                diffs.splice(0, 0, [DIFF_EQUAL, text_insert.substring(0, commonlength)]);\n                pointer++;\n              }\n              text_insert = text_insert.substring(commonlength);\n              text_delete = text_delete.substring(commonlength);\n            }\n            // Factor out any common suffixes.\n            commonlength = diff_commonSuffix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              diffs[pointer][1] =\n                text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];\n              text_insert = text_insert.substring(0, text_insert.length - commonlength);\n              text_delete = text_delete.substring(0, text_delete.length - commonlength);\n            }\n          }\n          // Delete the offending records and add the merged ones.\n          var n = count_insert + count_delete;\n          if (text_delete.length === 0 && text_insert.length === 0) {\n            diffs.splice(pointer - n, n);\n            pointer = pointer - n;\n          } else if (text_delete.length === 0) {\n            diffs.splice(pointer - n, n, [DIFF_INSERT, text_insert]);\n            pointer = pointer - n + 1;\n          } else if (text_insert.length === 0) {\n            diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete]);\n            pointer = pointer - n + 1;\n          } else {\n            diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete], [DIFF_INSERT, text_insert]);\n            pointer = pointer - n + 2;\n          }\n        }\n        if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {\n          // Merge this equality with the previous one.\n          diffs[pointer - 1][1] += diffs[pointer][1];\n          diffs.splice(pointer, 1);\n        } else {\n          pointer++;\n        }\n        count_insert = 0;\n        count_delete = 0;\n        text_delete = '';\n        text_insert = '';\n        break;\n    }\n  }\n  if (diffs[diffs.length - 1][1] === '') {\n    diffs.pop();  // Remove the dummy entry at the end.\n  }\n\n  // Second pass: look for single edits surrounded on both sides by equalities\n  // which can be shifted sideways to eliminate an equality.\n  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC\n  var changes = false;\n  pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (diffs[pointer - 1][0] === DIFF_EQUAL &&\n      diffs[pointer + 1][0] === DIFF_EQUAL) {\n      // This is a single edit surrounded by equalities.\n      if (diffs[pointer][1].substring(diffs[pointer][1].length -\n        diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {\n        // Shift the edit over the previous equality.\n        diffs[pointer][1] = diffs[pointer - 1][1] +\n          diffs[pointer][1].substring(0, diffs[pointer][1].length -\n            diffs[pointer - 1][1].length);\n        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n        diffs.splice(pointer - 1, 1);\n        changes = true;\n      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n        diffs[pointer + 1][1]) {\n        // Shift the edit over the next equality.\n        diffs[pointer - 1][1] += diffs[pointer + 1][1];\n        diffs[pointer][1] =\n          diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\n          diffs[pointer + 1][1];\n        diffs.splice(pointer + 1, 1);\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n  // If shifts were made, the diff needs reordering and another shift sweep.\n  if (changes) {\n    diff_cleanupMerge(diffs, fix_unicode);\n  }\n};\n\nfunction is_surrogate_pair_start(charCode) {\n  return charCode >= 0xD800 && charCode <= 0xDBFF;\n}\n\nfunction is_surrogate_pair_end(charCode) {\n  return charCode >= 0xDC00 && charCode <= 0xDFFF;\n}\n\nfunction starts_with_pair_end(str) {\n  return is_surrogate_pair_end(str.charCodeAt(0));\n}\n\nfunction ends_with_pair_start(str) {\n  return is_surrogate_pair_start(str.charCodeAt(str.length - 1));\n}\n\nfunction remove_empty_tuples(tuples) {\n  var ret = [];\n  for (var i = 0; i < tuples.length; i++) {\n    if (tuples[i][1].length > 0) {\n      ret.push(tuples[i]);\n    }\n  }\n  return ret;\n}\n\nfunction make_edit_splice(before, oldMiddle, newMiddle, after) {\n  if (ends_with_pair_start(before) || starts_with_pair_end(after)) {\n    return null;\n  }\n  return remove_empty_tuples([\n    [DIFF_EQUAL, before],\n    [DIFF_DELETE, oldMiddle],\n    [DIFF_INSERT, newMiddle],\n    [DIFF_EQUAL, after]\n  ]);\n}\n\nfunction find_cursor_edit_diff(oldText, newText, cursor_pos) {\n  // note: this runs after equality check has ruled out exact equality\n  var oldRange = typeof cursor_pos === 'number' ?\n    { index: cursor_pos, length: 0 } : cursor_pos.oldRange;\n  var newRange = typeof cursor_pos === 'number' ?\n    null : cursor_pos.newRange;\n  // take into account the old and new selection to generate the best diff\n  // possible for a text edit.  for example, a text change from \"xxx\" to \"xx\"\n  // could be a delete or forwards-delete of any one of the x's, or the\n  // result of selecting two of the x's and typing \"x\".\n  var oldLength = oldText.length;\n  var newLength = newText.length;\n  if (oldRange.length === 0 && (newRange === null || newRange.length === 0)) {\n    // see if we have an insert or delete before or after cursor\n    var oldCursor = oldRange.index;\n    var oldBefore = oldText.slice(0, oldCursor);\n    var oldAfter = oldText.slice(oldCursor);\n    var maybeNewCursor = newRange ? newRange.index : null;\n    editBefore: {\n      // is this an insert or delete right before oldCursor?\n      var newCursor = oldCursor + newLength - oldLength;\n      if (maybeNewCursor !== null && maybeNewCursor !== newCursor) {\n        break editBefore;\n      }\n      if (newCursor < 0 || newCursor > newLength) {\n        break editBefore;\n      }\n      var newBefore = newText.slice(0, newCursor);\n      var newAfter = newText.slice(newCursor);\n      if (newAfter !== oldAfter) {\n        break editBefore;\n      }\n      var prefixLength = Math.min(oldCursor, newCursor);\n      var oldPrefix = oldBefore.slice(0, prefixLength);\n      var newPrefix = newBefore.slice(0, prefixLength);\n      if (oldPrefix !== newPrefix) {\n        break editBefore;\n      }\n      var oldMiddle = oldBefore.slice(prefixLength);\n      var newMiddle = newBefore.slice(prefixLength);\n      return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldAfter);\n    }\n    editAfter: {\n      // is this an insert or delete right after oldCursor?\n      if (maybeNewCursor !== null && maybeNewCursor !== oldCursor) {\n        break editAfter;\n      }\n      var cursor = oldCursor;\n      var newBefore = newText.slice(0, cursor);\n      var newAfter = newText.slice(cursor);\n      if (newBefore !== oldBefore) {\n        break editAfter;\n      }\n      var suffixLength = Math.min(oldLength - cursor, newLength - cursor);\n      var oldSuffix = oldAfter.slice(oldAfter.length - suffixLength);\n      var newSuffix = newAfter.slice(newAfter.length - suffixLength);\n      if (oldSuffix !== newSuffix) {\n        break editAfter;\n      }\n      var oldMiddle = oldAfter.slice(0, oldAfter.length - suffixLength);\n      var newMiddle = newAfter.slice(0, newAfter.length - suffixLength);\n      return make_edit_splice(oldBefore, oldMiddle, newMiddle, oldSuffix);\n    }\n  }\n  if (oldRange.length > 0 && newRange && newRange.length === 0) {\n    replaceRange: {\n      // see if diff could be a splice of the old selection range\n      var oldPrefix = oldText.slice(0, oldRange.index);\n      var oldSuffix = oldText.slice(oldRange.index + oldRange.length);\n      var prefixLength = oldPrefix.length;\n      var suffixLength = oldSuffix.length;\n      if (newLength < prefixLength + suffixLength) {\n        break replaceRange;\n      }\n      var newPrefix = newText.slice(0, prefixLength);\n      var newSuffix = newText.slice(newLength - suffixLength);\n      if (oldPrefix !== newPrefix || oldSuffix !== newSuffix) {\n        break replaceRange;\n      }\n      var oldMiddle = oldText.slice(prefixLength, oldLength - suffixLength);\n      var newMiddle = newText.slice(prefixLength, newLength - suffixLength);\n      return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldSuffix);\n    }\n  }\n\n  return null;\n}\n\nfunction diff(text1, text2, cursor_pos) {\n  // only pass fix_unicode=true at the top level, not when diff_main is\n  // recursively invoked\n  return diff_main(text1, text2, cursor_pos, true);\n}\n\ndiff.INSERT = DIFF_INSERT;\ndiff.DELETE = DIFF_DELETE;\ndiff.EQUAL = DIFF_EQUAL;\n\nmodule.exports = diff;\n"],"names":["DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","diff_main","text1","text2","cursor_pos","_fix_unicode","editdiff","find_cursor_edit_diff","commonlength","diff_commonPrefix","commonprefix","diff_commonSuffix","commonsuffix","diffs","diff_compute_","diff_cleanupMerge","longtext","shorttext","i","hm","diff_halfMatch_","text1_a","text1_b","text2_a","text2_b","mid_common","diffs_a","diffs_b","diff_bisect_","text1_length","text2_length","max_d","v_offset","v_length","v1","v2","x","delta","front","k1start","k1end","k2start","k2end","d","k1","k1_offset","x1","y1","k2_offset","x2","diff_bisectSplit_","k2","y2","y","text1a","text2a","text1b","text2b","diffsb","pointermin","pointermax","pointermid","pointerstart","is_surrogate_pair_start","pointerend","is_surrogate_pair_end","diff_halfMatchI_","seed","j","best_common","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","prefixLength","suffixLength","hm1","hm2","fix_unicode","pointer","count_delete","count_insert","text_delete","text_insert","previous_equality","ends_with_pair_start","stray","k","starts_with_pair_end","n","changes","charCode","str","remove_empty_tuples","tuples","ret","make_edit_splice","before","oldMiddle","newMiddle","after","oldText","newText","oldRange","newRange","oldLength","newLength","oldCursor","oldBefore","oldAfter","maybeNewCursor","editBefore","newCursor","newBefore","newAfter","oldPrefix","newPrefix","editAfter","cursor","oldSuffix","newSuffix","replaceRange","diff","diff_1"],"mappings":"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","x_google_ignoreList":[0]}