@vivliostyle/print 2.26.0 → 2.28.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/README.md +1 -0
  2. package/demo/index.js +4 -0
  3. package/dist/index.cjs.js +2 -2
  4. package/dist/index.cjs.js.map +1 -1
  5. package/dist/index.es6.js +2 -2
  6. package/dist/index.es6.js.map +1 -1
  7. package/package.json +2 -2
package/dist/index.cjs.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.cjs.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_main","text1","text2","cursor_pos","_fix_unicode","editdiff","oldText","newText","oldRange","index","length","newRange","oldLength","newLength","oldCursor","oldBefore","slice","oldAfter","maybeNewCursor","newCursor","newBefore","newAfter","prefixLength","Math","min","oldPrefix","newPrefix","make_edit_splice","cursor","suffixLength","oldSuffix","newSuffix","find_cursor_edit_diff","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diffs","longtext","shorttext","i","indexOf","hm","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","floor","j","best_common","text1_a","text1_b","text2_a","text2_b","hm1","ceil","hm2","mid_common","diff_halfMatch_","diffs_a","diffs_b","concat","text1_length","text2_length","max_d","v_offset","v_length","v1","Array","v2","x","delta","front","k1start","k1end","k2start","k2end","d","k1","k1_offset","y1","x1","charAt","k2_offset","x2","diff_bisectSplit_","k2","y2","diff_bisect_","diff_compute_","unshift","push","diff_cleanupMerge","y","text1a","text2a","text1b","text2b","diffsb","pointermin","pointermax","pointermid","pointerstart","is_surrogate_pair_start","charCodeAt","pointerend","is_surrogate_pair_end","fix_unicode","pointer","count_delete","count_insert","text_delete","text_insert","splice","previous_equality","ends_with_pair_start","stray","k","starts_with_pair_end","n","pop","changes","charCode","str","before","oldMiddle","newMiddle","after","tuples","ret","remove_empty_tuples","diff","INSERT","DELETE","EQUAL","diff_1"],"mappings":"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"}
1
+ {"version":3,"file":"index.cjs.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 * 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 * 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 * @param {boolean} [cleanup] Apply semantic cleanup before returning.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_main(text1, text2, cursor_pos, cleanup, _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 if (cleanup) {\n diff_cleanupSemantic(diffs);\n }\n return diffs;\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 [\n [DIFF_DELETE, text1],\n [DIFF_INSERT, text2],\n ];\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 * 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 &&\n 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 &&\n y2 < text2_length &&\n text1.charAt(text1_length - x2 - 1) ===\n 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 [\n [DIFF_DELETE, text1],\n [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 * 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 * Determine if the suffix of one string is the prefix of another.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of the first\n * string and the start of the second string.\n * @private\n */\nfunction diff_commonOverlap_(text1, text2) {\n // Cache the text lengths to prevent multiple calls.\n var text1_length = text1.length;\n var text2_length = text2.length;\n // Eliminate the null case.\n if (text1_length == 0 || text2_length == 0) {\n return 0;\n }\n // Truncate the longer string.\n if (text1_length > text2_length) {\n text1 = text1.substring(text1_length - text2_length);\n } else if (text1_length < text2_length) {\n text2 = text2.substring(0, text1_length);\n }\n var text_length = Math.min(text1_length, text2_length);\n // Quick check for the worst case.\n if (text1 == text2) {\n return text_length;\n }\n\n // Start by looking for a single character match\n // and increase length until no match is found.\n // Performance analysis: http://neil.fraser.name/news/2010/11/04/\n var best = 0;\n var length = 1;\n while (true) {\n var pattern = text1.substring(text_length - length);\n var found = text2.indexOf(pattern);\n if (found == -1) {\n return best;\n }\n length += found;\n if (\n found == 0 ||\n text1.substring(text_length - length) == text2.substring(0, length)\n ) {\n best = length;\n length++;\n }\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 * 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),\n shorttext.substring(j)\n );\n var suffixLength = diff_commonSuffix(\n longtext.substring(0, i),\n shorttext.substring(0, j)\n );\n if (best_common.length < suffixLength + prefixLength) {\n best_common =\n shorttext.substring(j - suffixLength, j) +\n 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,\n best_longtext_b,\n best_shorttext_a,\n best_shorttext_b,\n 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_(\n longtext,\n shorttext,\n Math.ceil(longtext.length / 4)\n );\n // Check again based on the third quarter.\n var hm2 = diff_halfMatchI_(\n longtext,\n shorttext,\n Math.ceil(longtext.length / 2)\n );\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 * Reduce the number of edits by eliminating semantically trivial equalities.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\nfunction diff_cleanupSemantic(diffs) {\n var changes = false;\n var equalities = []; // Stack of indices where equalities are found.\n var equalitiesLength = 0; // Keeping our own length var is faster in JS.\n /** @type {?string} */\n var lastequality = null;\n // Always equal to diffs[equalities[equalitiesLength - 1]][1]\n var pointer = 0; // Index of current position.\n // Number of characters that changed prior to the equality.\n var length_insertions1 = 0;\n var length_deletions1 = 0;\n // Number of characters that changed after the equality.\n var length_insertions2 = 0;\n var length_deletions2 = 0;\n while (pointer < diffs.length) {\n if (diffs[pointer][0] == DIFF_EQUAL) {\n // Equality found.\n equalities[equalitiesLength++] = pointer;\n length_insertions1 = length_insertions2;\n length_deletions1 = length_deletions2;\n length_insertions2 = 0;\n length_deletions2 = 0;\n lastequality = diffs[pointer][1];\n } else {\n // An insertion or deletion.\n if (diffs[pointer][0] == DIFF_INSERT) {\n length_insertions2 += diffs[pointer][1].length;\n } else {\n length_deletions2 += diffs[pointer][1].length;\n }\n // Eliminate an equality that is smaller or equal to the edits on both\n // sides of it.\n if (\n lastequality &&\n lastequality.length <=\n Math.max(length_insertions1, length_deletions1) &&\n lastequality.length <= Math.max(length_insertions2, length_deletions2)\n ) {\n // Duplicate record.\n diffs.splice(equalities[equalitiesLength - 1], 0, [\n DIFF_DELETE,\n lastequality,\n ]);\n // Change second copy to insert.\n diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n // Throw away the equality we just deleted.\n equalitiesLength--;\n // Throw away the previous equality (it needs to be reevaluated).\n equalitiesLength--;\n pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\n length_insertions1 = 0; // Reset the counters.\n length_deletions1 = 0;\n length_insertions2 = 0;\n length_deletions2 = 0;\n lastequality = null;\n changes = true;\n }\n }\n pointer++;\n }\n\n // Normalize the diff.\n if (changes) {\n diff_cleanupMerge(diffs);\n }\n diff_cleanupSemanticLossless(diffs);\n\n // Find any overlaps between deletions and insertions.\n // e.g: <del>abcxxx</del><ins>xxxdef</ins>\n // -> <del>abc</del>xxx<ins>def</ins>\n // e.g: <del>xxxabc</del><ins>defxxx</ins>\n // -> <ins>def</ins>xxx<del>abc</del>\n // Only extract an overlap if it is as big as the edit ahead or behind it.\n pointer = 1;\n while (pointer < diffs.length) {\n if (\n diffs[pointer - 1][0] == DIFF_DELETE &&\n diffs[pointer][0] == DIFF_INSERT\n ) {\n var deletion = diffs[pointer - 1][1];\n var insertion = diffs[pointer][1];\n var overlap_length1 = diff_commonOverlap_(deletion, insertion);\n var overlap_length2 = diff_commonOverlap_(insertion, deletion);\n if (overlap_length1 >= overlap_length2) {\n if (\n overlap_length1 >= deletion.length / 2 ||\n overlap_length1 >= insertion.length / 2\n ) {\n // Overlap found. Insert an equality and trim the surrounding edits.\n diffs.splice(pointer, 0, [\n DIFF_EQUAL,\n insertion.substring(0, overlap_length1),\n ]);\n diffs[pointer - 1][1] = deletion.substring(\n 0,\n deletion.length - overlap_length1\n );\n diffs[pointer + 1][1] = insertion.substring(overlap_length1);\n pointer++;\n }\n } else {\n if (\n overlap_length2 >= deletion.length / 2 ||\n overlap_length2 >= insertion.length / 2\n ) {\n // Reverse overlap found.\n // Insert an equality and swap and trim the surrounding edits.\n diffs.splice(pointer, 0, [\n DIFF_EQUAL,\n deletion.substring(0, overlap_length2),\n ]);\n diffs[pointer - 1][0] = DIFF_INSERT;\n diffs[pointer - 1][1] = insertion.substring(\n 0,\n insertion.length - overlap_length2\n );\n diffs[pointer + 1][0] = DIFF_DELETE;\n diffs[pointer + 1][1] = deletion.substring(overlap_length2);\n pointer++;\n }\n }\n pointer++;\n }\n pointer++;\n }\n}\n\nvar nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\nvar whitespaceRegex_ = /\\s/;\nvar linebreakRegex_ = /[\\r\\n]/;\nvar blanklineEndRegex_ = /\\n\\r?\\n$/;\nvar blanklineStartRegex_ = /^\\r?\\n\\r?\\n/;\n\n/**\n * Look for single edits surrounded on both sides by equalities\n * which can be shifted sideways to align the edit to a word boundary.\n * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\nfunction diff_cleanupSemanticLossless(diffs) {\n /**\n * Given two strings, compute a score representing whether the internal\n * boundary falls on logical boundaries.\n * Scores range from 6 (best) to 0 (worst).\n * Closure, but does not reference any external variables.\n * @param {string} one First string.\n * @param {string} two Second string.\n * @return {number} The score.\n * @private\n */\n function diff_cleanupSemanticScore_(one, two) {\n if (!one || !two) {\n // Edges are the best.\n return 6;\n }\n\n // Each port of this function behaves slightly differently due to\n // subtle differences in each language's definition of things like\n // 'whitespace'. Since this function's purpose is largely cosmetic,\n // the choice has been made to use each language's native features\n // rather than force total conformity.\n var char1 = one.charAt(one.length - 1);\n var char2 = two.charAt(0);\n var nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);\n var nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);\n var whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);\n var whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);\n var lineBreak1 = whitespace1 && char1.match(linebreakRegex_);\n var lineBreak2 = whitespace2 && char2.match(linebreakRegex_);\n var blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);\n var blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);\n\n if (blankLine1 || blankLine2) {\n // Five points for blank lines.\n return 5;\n } else if (lineBreak1 || lineBreak2) {\n // Four points for line breaks.\n return 4;\n } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\n // Three points for end of sentences.\n return 3;\n } else if (whitespace1 || whitespace2) {\n // Two points for whitespace.\n return 2;\n } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\n // One point for non-alphanumeric.\n return 1;\n }\n return 0;\n }\n\n var pointer = 1;\n // Intentionally ignore the first and last element (don't need checking).\n while (pointer < diffs.length - 1) {\n if (\n diffs[pointer - 1][0] == DIFF_EQUAL &&\n diffs[pointer + 1][0] == DIFF_EQUAL\n ) {\n // This is a single edit surrounded by equalities.\n var equality1 = diffs[pointer - 1][1];\n var edit = diffs[pointer][1];\n var equality2 = diffs[pointer + 1][1];\n\n // First, shift the edit as far left as possible.\n var commonOffset = diff_commonSuffix(equality1, edit);\n if (commonOffset) {\n var commonString = edit.substring(edit.length - commonOffset);\n equality1 = equality1.substring(0, equality1.length - commonOffset);\n edit = commonString + edit.substring(0, edit.length - commonOffset);\n equality2 = commonString + equality2;\n }\n\n // Second, step character by character right, looking for the best fit.\n var bestEquality1 = equality1;\n var bestEdit = edit;\n var bestEquality2 = equality2;\n var bestScore =\n diff_cleanupSemanticScore_(equality1, edit) +\n diff_cleanupSemanticScore_(edit, equality2);\n while (edit.charAt(0) === equality2.charAt(0)) {\n equality1 += edit.charAt(0);\n edit = edit.substring(1) + equality2.charAt(0);\n equality2 = equality2.substring(1);\n var score =\n diff_cleanupSemanticScore_(equality1, edit) +\n diff_cleanupSemanticScore_(edit, equality2);\n // The >= encourages trailing rather than leading whitespace on edits.\n if (score >= bestScore) {\n bestScore = score;\n bestEquality1 = equality1;\n bestEdit = edit;\n bestEquality2 = equality2;\n }\n }\n\n if (diffs[pointer - 1][1] != bestEquality1) {\n // We have an improvement, save it back to the diff.\n if (bestEquality1) {\n diffs[pointer - 1][1] = bestEquality1;\n } else {\n diffs.splice(pointer - 1, 1);\n pointer--;\n }\n diffs[pointer][1] = bestEdit;\n if (bestEquality2) {\n diffs[pointer + 1][1] = bestEquality2;\n } else {\n diffs.splice(pointer + 1, 1);\n pointer--;\n }\n }\n }\n pointer++;\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 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 (\n previous_equality >= 0 &&\n ends_with_pair_start(diffs[previous_equality][1])\n ) {\n var stray = diffs[previous_equality][1].slice(-1);\n diffs[previous_equality][1] = diffs[previous_equality][1].slice(\n 0,\n -1\n );\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(\n 0,\n commonlength\n );\n } else {\n diffs.splice(0, 0, [\n DIFF_EQUAL,\n text_insert.substring(0, commonlength),\n ]);\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) +\n diffs[pointer][1];\n text_insert = text_insert.substring(\n 0,\n text_insert.length - commonlength\n );\n text_delete = text_delete.substring(\n 0,\n text_delete.length - commonlength\n );\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(\n pointer - n,\n n,\n [DIFF_DELETE, text_delete],\n [DIFF_INSERT, text_insert]\n );\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 (\n diffs[pointer - 1][0] === DIFF_EQUAL &&\n diffs[pointer + 1][0] === DIFF_EQUAL\n ) {\n // This is a single edit surrounded by equalities.\n if (\n diffs[pointer][1].substring(\n diffs[pointer][1].length - diffs[pointer - 1][1].length\n ) === diffs[pointer - 1][1]\n ) {\n // Shift the edit over the previous equality.\n diffs[pointer][1] =\n diffs[pointer - 1][1] +\n diffs[pointer][1].substring(\n 0,\n diffs[pointer][1].length - diffs[pointer - 1][1].length\n );\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 (\n diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n diffs[pointer + 1][1]\n ) {\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 =\n typeof cursor_pos === \"number\"\n ? { index: cursor_pos, length: 0 }\n : cursor_pos.oldRange;\n var newRange = typeof cursor_pos === \"number\" ? 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, cleanup) {\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, cleanup, 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","cleanup","_fix_unicode","editdiff","oldText","newText","oldRange","index","length","newRange","oldLength","newLength","oldCursor","oldBefore","slice","oldAfter","maybeNewCursor","newCursor","newBefore","newAfter","prefixLength","Math","min","oldPrefix","newPrefix","make_edit_splice","cursor","suffixLength","oldSuffix","newSuffix","find_cursor_edit_diff","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diffs","longtext","shorttext","i","indexOf","hm","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","floor","j","best_common","text1_a","text1_b","text2_a","text2_b","hm1","ceil","hm2","mid_common","diff_halfMatch_","diffs_a","diffs_b","concat","text1_length","text2_length","max_d","v_offset","v_length","v1","Array","v2","x","delta","front","k1start","k1end","k2start","k2end","d","k1","k1_offset","y1","x1","charAt","k2_offset","x2","diff_bisectSplit_","k2","y2","diff_bisect_","diff_compute_","unshift","push","diff_cleanupMerge","changes","equalities","equalitiesLength","lastequality","pointer","length_insertions1","length_deletions1","length_insertions2","length_deletions2","max","splice","diff_cleanupSemanticScore_","one","two","char1","char2","nonAlphaNumeric1","match","nonAlphaNumericRegex_","nonAlphaNumeric2","whitespace1","whitespaceRegex_","whitespace2","lineBreak1","linebreakRegex_","lineBreak2","blankLine1","blanklineEndRegex_","blankLine2","blanklineStartRegex_","equality1","edit","equality2","commonOffset","commonString","bestEquality1","bestEdit","bestEquality2","bestScore","score","diff_cleanupSemanticLossless","deletion","insertion","overlap_length1","diff_commonOverlap_","overlap_length2","diff_cleanupSemantic","y","text1a","text2a","text1b","text2b","diffsb","pointermin","pointermax","pointermid","pointerstart","is_surrogate_pair_start","charCodeAt","text_length","best","pattern","found","pointerend","is_surrogate_pair_end","fix_unicode","count_delete","count_insert","text_delete","text_insert","previous_equality","ends_with_pair_start","stray","k","starts_with_pair_end","n","pop","charCode","str","before","oldMiddle","newMiddle","after","tuples","ret","remove_empty_tuples","diff","INSERT","DELETE","EQUAL","diff_1"],"mappings":"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"}