{"version":3,"sources":["../js/Text/GreenlightTextCompare_DiffMatchPatch.js"],"names":["diff_match_patch","this","Diff_Timeout","Diff_EditCost","Match_Threshold","Match_Distance","Patch_DeleteThreshold","Patch_Margin","Match_MaxBits","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","Diff","op","text","prototype","length","toString","diff_main","text1","text2","opt_checklines","opt_deadline","Number","MAX_VALUE","Date","getTime","deadline","Error","checklines","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diffs","diff_compute_","unshift","push","diff_cleanupMerge","longtext","shorttext","i","indexOf","hm","diff_halfMatch_","text1_a","text1_b","text2_a","text2_b","mid_common","diffs_a","diffs_b","concat","diff_lineMode_","diff_bisect_","a","diff_linesToChars_","chars1","chars2","linearray","lineArray","diff_charsToLines_","diff_cleanupSemantic","pointer","count_delete","count_insert","text_delete","text_insert","splice","subDiff","j","pop","text1_length","text2_length","max_d","Math","ceil","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","y","text1a","text2a","text1b","text2b","diffsb","lineHash","diff_linesToCharsMunge_","chars","lineStart","lineEnd","lineArrayLength","line","hasOwnProperty","undefined","String","fromCharCode","maxLines","diff_linesToWords_","charCodeAt","join","pointermin","pointermax","min","pointermid","pointerstart","floor","pointerend","diff_commonOverlap_","text_length","best","pattern","found","dmp","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","best_common","prefixLength","suffixLength","hm1","hm2","diff_cleanupBlankValues","diff_cleanupBlankValuesCharacters","spaceSubbed","0","1","replace","changes","equalities","equalitiesLength","lastEquality","length_insertions1","length_deletions1","length_insertions2","length_deletions2","max","diff_cleanupSemanticLossless","deletion","insertion","overlap_length1","overlap_length2","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_cleanupEfficiency","pre_ins","pre_del","post_ins","post_del","diff_xIndex","loc","last_chars1","last_chars2","diff_prettyHtml","html","pattern_amp","pattern_lt","pattern_gt","pattern_para","diff_text1","diff_text2","diff_levenshtein","levenshtein","insertions","deletions","data","diff_toDelta","encodeURI","diff_fromDelta","diffsLength","tokens","split","param","decodeURI","ex","n","parseInt","isNaN","match_main","match_bitap_","s","match_alphabet_","match_bitapScore_","e","accuracy","proximity","abs","score_threshold","best_loc","lastIndexOf","bin_min","bin_mid","matchmask","last_rd","bin_max","start","finish","rd","charMatch","patch_addContext_","patch","start2","length1","padding","prefix","suffix","start1","length2","patch_make","opt_b","opt_c","patches","patch_obj","patchDiffLength","char_count1","char_count2","prepatch_text","postpatch_text","diff_type","diff_text","patch_deepCopy","patchesCopy","patchCopy","patch_apply","nullPadding","patch_addPadding","patch_splitMax","results","start_loc","expected_loc","end_loc","index2","index1","mod","paddingLength","extraLength","patch_size","bigpatch","precontext","empty","shift","postcontext","patch_toText","patch_fromText","textline","textPointer","patchHeader","m","sign"],"mappings":"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","file":"GreenlightTextCompare_DiffMatchPatch-02a48e5611.js","sourcesContent":["/**\r\n * Diff Match and Patch\r\n * Copyright 2018 The diff-match-patch Authors.\r\n * https://github.com/google/diff-match-patch\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\n/**\r\n * @fileoverview Computes the difference between two texts to create a patch.\r\n * Applies the patch onto another text, allowing for errors.\r\n * @author fraser@google.com (Neil Fraser)\r\n */\r\n\r\n/**\r\n * Class containing the diff, match and patch methods.\r\n * @constructor\r\n */\r\nvar diff_match_patch = function () {\r\n\r\n    // Defaults.\r\n    // Redefine these in your program to override the defaults.\r\n\r\n    // Number of seconds to map a diff before giving up (0 for infinity).\r\n    this.Diff_Timeout = 1.0;\r\n    // Cost of an empty edit operation in terms of edit characters.\r\n    this.Diff_EditCost = 4;\r\n    // At what point is no match declared (0.0 = perfection, 1.0 = very loose).\r\n    this.Match_Threshold = 0.5;\r\n    // How far to search for a match (0 = exact location, 1000+ = broad match).\r\n    // A match this many characters away from the expected location will add\r\n    // 1.0 to the score (0.0 is a perfect match).\r\n    this.Match_Distance = 1000;\r\n    // When deleting a large block of text (over ~64 characters), how close do\r\n    // the contents have to be to match the expected contents. (0.0 = perfection,\r\n    // 1.0 = very loose).  Note that Match_Threshold controls how closely the\r\n    // end points of a delete need to match.\r\n    this.Patch_DeleteThreshold = 0.5;\r\n    // Chunk size for context length.\r\n    this.Patch_Margin = 4;\r\n\r\n    // The number of bits in an int.\r\n    this.Match_MaxBits = 32;\r\n};\r\n\r\n\r\n//  DIFF FUNCTIONS\r\n\r\n\r\n/**\r\n * The data structure representing a diff is an array of tuples:\r\n * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\r\n * which means: delete 'Hello', add 'Goodbye' and keep ' world.'\r\n */\r\nvar DIFF_DELETE = -1;\r\nvar DIFF_INSERT = 1;\r\nvar DIFF_EQUAL = 0;\r\n\r\n/**\r\n * Class representing one diff tuple.\r\n * Attempts to look like a two-element array (which is what this used to be).\r\n * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.\r\n * @param {string} text Text to be deleted, inserted, or retained.\r\n * @constructor\r\n */\r\ndiff_match_patch.Diff = function (op, text) {\r\n    this[0] = op;\r\n    this[1] = text;\r\n};\r\n\r\ndiff_match_patch.Diff.prototype.length = 2;\r\n\r\n/**\r\n * Emulate the output of a two-element array.\r\n * @return {string} Diff operation as a string.\r\n */\r\ndiff_match_patch.Diff.prototype.toString = function () {\r\n    return this[0] + ',' + this[1];\r\n};\r\n\r\n\r\n/**\r\n * Find the differences between two texts.  Simplifies the problem by stripping\r\n * any common prefix or suffix off the texts before diffing.\r\n * @param {string} text1 Old string to be diffed.\r\n * @param {string} text2 New string to be diffed.\r\n * @param {boolean=} opt_checklines Optional speedup flag. If present and false,\r\n *     then don't run a line-level diff first to identify the changed areas.\r\n *     Defaults to true, which does a faster, slightly less optimal diff.\r\n * @param {number=} opt_deadline Optional time when the diff should be complete\r\n *     by.  Used internally for recursive calls.  Users should set DiffTimeout\r\n *     instead.\r\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\r\n */\r\ndiff_match_patch.prototype.diff_main = function (text1, text2, opt_checklines,\r\n    opt_deadline) {\r\n    // Set a deadline by which time the diff must be complete.\r\n    if (typeof opt_deadline == 'undefined') {\r\n        if (this.Diff_Timeout <= 0) {\r\n            opt_deadline = Number.MAX_VALUE;\r\n        } else {\r\n            opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000;\r\n        }\r\n    }\r\n    var deadline = opt_deadline;\r\n\r\n    // Check for null inputs.\r\n    if (text1 == null || text2 == null) {\r\n        throw new Error('Null input. (diff_main)');\r\n    }\r\n\r\n    // Check for equality (speedup).\r\n    if (text1 == text2) {\r\n        if (text1) {\r\n            return [new diff_match_patch.Diff(DIFF_EQUAL, text1)];\r\n        }\r\n        return [];\r\n    }\r\n\r\n    if (typeof opt_checklines == 'undefined') {\r\n        opt_checklines = true;\r\n    }\r\n    var checklines = opt_checklines;\r\n\r\n    // Trim off common prefix (speedup).\r\n    var commonlength = this.diff_commonPrefix(text1, text2);\r\n    var commonprefix = text1.substring(0, commonlength);\r\n    text1 = text1.substring(commonlength);\r\n    text2 = text2.substring(commonlength);\r\n\r\n    // Trim off common suffix (speedup).\r\n    commonlength = this.diff_commonSuffix(text1, text2);\r\n    var commonsuffix = text1.substring(text1.length - commonlength);\r\n    text1 = text1.substring(0, text1.length - commonlength);\r\n    text2 = text2.substring(0, text2.length - commonlength);\r\n\r\n    // Compute the diff on the middle block.\r\n    var diffs = this.diff_compute_(text1, text2, checklines, deadline);\r\n\r\n    // Restore the prefix and suffix.\r\n    if (commonprefix) {\r\n        diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, commonprefix));\r\n    }\r\n    if (commonsuffix) {\r\n        diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, commonsuffix));\r\n    }\r\n    this.diff_cleanupMerge(diffs);\r\n    return diffs;\r\n};\r\n\r\n\r\n/**\r\n * Find the differences between two texts.  Assumes that the texts do not\r\n * have any common prefix or suffix.\r\n * @param {string} text1 Old string to be diffed.\r\n * @param {string} text2 New string to be diffed.\r\n * @param {boolean} checklines Speedup flag.  If false, then don't run a\r\n *     line-level diff first to identify the changed areas.\r\n *     If true, then run a faster, slightly less optimal diff.\r\n * @param {number} deadline Time when the diff should be complete by.\r\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_compute_ = function (text1, text2, checklines,\r\n    deadline) {\r\n    var diffs;\r\n\r\n    if (!text1) {\r\n        // Just add some text (speedup).\r\n        return [new diff_match_patch.Diff(DIFF_INSERT, text2)];\r\n    }\r\n\r\n    if (!text2) {\r\n        // Just delete some text (speedup).\r\n        return [new diff_match_patch.Diff(DIFF_DELETE, text1)];\r\n    }\r\n\r\n    var longtext = text1.length > text2.length ? text1 : text2;\r\n    var shorttext = text1.length > text2.length ? text2 : text1;\r\n    var i = longtext.indexOf(shorttext);\r\n    if (i != -1) {\r\n        // Shorter text is inside the longer text (speedup).\r\n        diffs = [new diff_match_patch.Diff(DIFF_INSERT, longtext.substring(0, i)),\r\n        new diff_match_patch.Diff(DIFF_EQUAL, shorttext),\r\n        new diff_match_patch.Diff(DIFF_INSERT,\r\n            longtext.substring(i + shorttext.length))];\r\n        // Swap insertions for deletions if diff is reversed.\r\n        if (text1.length > text2.length) {\r\n            diffs[0][0] = diffs[2][0] = DIFF_DELETE;\r\n        }\r\n        return diffs;\r\n    }\r\n\r\n    if (shorttext.length == 1) {\r\n        // Single character string.\r\n        // After the previous speedup, the character can't be an equality.\r\n        return [new diff_match_patch.Diff(DIFF_DELETE, text1),\r\n        new diff_match_patch.Diff(DIFF_INSERT, text2)];\r\n    }\r\n\r\n    // Check to see if the problem can be split in two.\r\n    var hm = this.diff_halfMatch_(text1, text2);\r\n    if (hm) {\r\n        // A half-match was found, sort out the return data.\r\n        var text1_a = hm[0];\r\n        var text1_b = hm[1];\r\n        var text2_a = hm[2];\r\n        var text2_b = hm[3];\r\n        var mid_common = hm[4];\r\n        // Send both pairs off for separate processing.\r\n        var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);\r\n        var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);\r\n        // Merge the results.\r\n        return diffs_a.concat([new diff_match_patch.Diff(DIFF_EQUAL, mid_common)],\r\n            diffs_b);\r\n    }\r\n\r\n    if (checklines && text1.length > 100 && text2.length > 100) {\r\n        return this.diff_lineMode_(text1, text2, deadline);\r\n    }\r\n\r\n    return this.diff_bisect_(text1, text2, deadline);\r\n};\r\n\r\n\r\n/**\r\n * Do a quick line-level diff on both strings, then rediff the parts for\r\n * greater accuracy.\r\n * This speedup can produce non-minimal diffs.\r\n * @param {string} text1 Old string to be diffed.\r\n * @param {string} text2 New string to be diffed.\r\n * @param {number} deadline Time when the diff should be complete by.\r\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_lineMode_ = function (text1, text2, deadline) {\r\n    // Scan the text on a line-by-line basis first.\r\n    var a = this.diff_linesToChars_(text1, text2);\r\n    text1 = a.chars1;\r\n    text2 = a.chars2;\r\n    var linearray = a.lineArray;\r\n\r\n    var diffs = this.diff_main(text1, text2, false, deadline);\r\n\r\n    // Convert the diff back to original text.\r\n    this.diff_charsToLines_(diffs, linearray);\r\n    // Eliminate freak matches (e.g. blank lines)\r\n    this.diff_cleanupSemantic(diffs);\r\n\r\n    // Rediff any replacement blocks, this time character-by-character.\r\n    // Add a dummy entry at the end.\r\n    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));\r\n    var pointer = 0;\r\n    var count_delete = 0;\r\n    var count_insert = 0;\r\n    var text_delete = '';\r\n    var text_insert = '';\r\n    while (pointer < diffs.length) {\r\n        switch (diffs[pointer][0]) {\r\n            case DIFF_INSERT:\r\n                count_insert++;\r\n                text_insert += diffs[pointer][1];\r\n                break;\r\n            case DIFF_DELETE:\r\n                count_delete++;\r\n                text_delete += diffs[pointer][1];\r\n                break;\r\n            case DIFF_EQUAL:\r\n                // Upon reaching an equality, check for prior redundancies.\r\n                if (count_delete >= 1 && count_insert >= 1) {\r\n                    // Delete the offending records and add the merged ones.\r\n                    diffs.splice(pointer - count_delete - count_insert,\r\n                        count_delete + count_insert);\r\n                    pointer = pointer - count_delete - count_insert;\r\n                    var subDiff =\r\n                        this.diff_main(text_delete, text_insert, false, deadline);\r\n                    for (var j = subDiff.length - 1; j >= 0; j--) {\r\n                        diffs.splice(pointer, 0, subDiff[j]);\r\n                    }\r\n                    pointer = pointer + subDiff.length;\r\n                }\r\n                count_insert = 0;\r\n                count_delete = 0;\r\n                text_delete = '';\r\n                text_insert = '';\r\n                break;\r\n        }\r\n        pointer++;\r\n    }\r\n    diffs.pop();  // Remove the dummy entry at the end.\r\n\r\n    return diffs;\r\n};\r\n\r\n\r\n/**\r\n * Find the 'middle snake' of a diff, split the problem in two\r\n * and return the recursively constructed diff.\r\n * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.\r\n * @param {string} text1 Old string to be diffed.\r\n * @param {string} text2 New string to be diffed.\r\n * @param {number} deadline Time at which to bail if not yet complete.\r\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_bisect_ = function (text1, text2, deadline) {\r\n    // Cache the text lengths to prevent multiple calls.\r\n    var text1_length = text1.length;\r\n    var text2_length = text2.length;\r\n    var max_d = Math.ceil((text1_length + text2_length) / 2);\r\n    var v_offset = max_d;\r\n    var v_length = 2 * max_d;\r\n    var v1 = new Array(v_length);\r\n    var v2 = new Array(v_length);\r\n    // Setting all elements to -1 is faster in Chrome & Firefox than mixing\r\n    // integers and undefined.\r\n    for (var x = 0; x < v_length; x++) {\r\n        v1[x] = -1;\r\n        v2[x] = -1;\r\n    }\r\n    v1[v_offset + 1] = 0;\r\n    v2[v_offset + 1] = 0;\r\n    var delta = text1_length - text2_length;\r\n    // If the total number of characters is odd, then the front path will collide\r\n    // with the reverse path.\r\n    var front = (delta % 2 != 0);\r\n    // Offsets for start and end of k loop.\r\n    // Prevents mapping of space beyond the grid.\r\n    var k1start = 0;\r\n    var k1end = 0;\r\n    var k2start = 0;\r\n    var k2end = 0;\r\n    for (var d = 0; d < max_d; d++) {\r\n        // Bail out if deadline is reached.\r\n        if ((new Date()).getTime() > deadline) {\r\n            break;\r\n        }\r\n\r\n        // Walk the front path one step.\r\n        for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\r\n            var k1_offset = v_offset + k1;\r\n            var x1;\r\n            if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {\r\n                x1 = v1[k1_offset + 1];\r\n            } else {\r\n                x1 = v1[k1_offset - 1] + 1;\r\n            }\r\n            var y1 = x1 - k1;\r\n            while (x1 < text1_length && y1 < text2_length &&\r\n                text1.charAt(x1) == text2.charAt(y1)) {\r\n                x1++;\r\n                y1++;\r\n            }\r\n            v1[k1_offset] = x1;\r\n            if (x1 > text1_length) {\r\n                // Ran off the right of the graph.\r\n                k1end += 2;\r\n            } else if (y1 > text2_length) {\r\n                // Ran off the bottom of the graph.\r\n                k1start += 2;\r\n            } else if (front) {\r\n                var k2_offset = v_offset + delta - k1;\r\n                if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {\r\n                    // Mirror x2 onto top-left coordinate system.\r\n                    var x2 = text1_length - v2[k2_offset];\r\n                    if (x1 >= x2) {\r\n                        // Overlap detected.\r\n                        return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Walk the reverse path one step.\r\n        for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\r\n            var k2_offset = v_offset + k2;\r\n            var x2;\r\n            if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {\r\n                x2 = v2[k2_offset + 1];\r\n            } else {\r\n                x2 = v2[k2_offset - 1] + 1;\r\n            }\r\n            var y2 = x2 - k2;\r\n            while (x2 < text1_length && y2 < text2_length &&\r\n                text1.charAt(text1_length - x2 - 1) ==\r\n                text2.charAt(text2_length - y2 - 1)) {\r\n                x2++;\r\n                y2++;\r\n            }\r\n            v2[k2_offset] = x2;\r\n            if (x2 > text1_length) {\r\n                // Ran off the left of the graph.\r\n                k2end += 2;\r\n            } else if (y2 > text2_length) {\r\n                // Ran off the top of the graph.\r\n                k2start += 2;\r\n            } else if (!front) {\r\n                var k1_offset = v_offset + delta - k2;\r\n                if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {\r\n                    var x1 = v1[k1_offset];\r\n                    var y1 = v_offset + x1 - k1_offset;\r\n                    // Mirror x2 onto top-left coordinate system.\r\n                    x2 = text1_length - x2;\r\n                    if (x1 >= x2) {\r\n                        // Overlap detected.\r\n                        return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    // Diff took too long and hit the deadline or\r\n    // number of diffs equals number of characters, no commonality at all.\r\n    return [new diff_match_patch.Diff(DIFF_DELETE, text1),\r\n    new diff_match_patch.Diff(DIFF_INSERT, text2)];\r\n};\r\n\r\n\r\n/**\r\n * Given the location of the 'middle snake', split the diff in two parts\r\n * and recurse.\r\n * @param {string} text1 Old string to be diffed.\r\n * @param {string} text2 New string to be diffed.\r\n * @param {number} x Index of split point in text1.\r\n * @param {number} y Index of split point in text2.\r\n * @param {number} deadline Time at which to bail if not yet complete.\r\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_bisectSplit_ = function (text1, text2, x, y,\r\n    deadline) {\r\n    var text1a = text1.substring(0, x);\r\n    var text2a = text2.substring(0, y);\r\n    var text1b = text1.substring(x);\r\n    var text2b = text2.substring(y);\r\n\r\n    // Compute both diffs serially.\r\n    var diffs = this.diff_main(text1a, text2a, false, deadline);\r\n    var diffsb = this.diff_main(text1b, text2b, false, deadline);\r\n\r\n    return diffs.concat(diffsb);\r\n};\r\n\r\n\r\n/**\r\n * Split two texts into an array of strings.  Reduce the texts to a string of\r\n * hashes where each Unicode character represents one line.\r\n * @param {string} text1 First string.\r\n * @param {string} text2 Second string.\r\n * @return {{chars1: string, chars2: string, lineArray: !Array.<string>}}\r\n *     An object containing the encoded text1, the encoded text2 and\r\n *     the array of unique strings.\r\n *     The zeroth element of the array of unique strings is intentionally blank.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_linesToChars_ = function (text1, text2) {\r\n    var lineArray = [];  // e.g. lineArray[4] == 'Hello\\n'\r\n    var lineHash = {};   // e.g. lineHash['Hello\\n'] == 4\r\n\r\n    // '\\x00' is a valid character, but various debuggers don't like it.\r\n    // So we'll insert a junk entry to avoid generating a null character.\r\n    lineArray[0] = '';\r\n\r\n    /**\r\n     * Split a text into an array of strings.  Reduce the texts to a string of\r\n     * hashes where each Unicode character represents one line.\r\n     * Modifies linearray and linehash through being a closure.\r\n     * @param {string} text String to encode.\r\n     * @return {string} Encoded string.\r\n     * @private\r\n     */\r\n    function diff_linesToCharsMunge_(text) {\r\n        var chars = '';\r\n        // Walk the text, pulling out a substring for each line.\r\n        // text.split('\\n') would would temporarily double our memory footprint.\r\n        // Modifying text would create many large strings to garbage collect.\r\n        var lineStart = 0;\r\n        var lineEnd = -1;\r\n        // Keeping our own length variable is faster than looking it up.\r\n        var lineArrayLength = lineArray.length;\r\n        while (lineEnd < text.length - 1) {\r\n            lineEnd = text.indexOf('\\n', lineStart);\r\n            if (lineEnd == -1) {\r\n                lineEnd = text.length - 1;\r\n            }\r\n            var line = text.substring(lineStart, lineEnd + 1);\r\n\r\n            if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :\r\n                (lineHash[line] !== undefined)) {\r\n                chars += String.fromCharCode(lineHash[line]);\r\n            } else {\r\n                if (lineArrayLength == maxLines) {\r\n                    // Bail out at 65535 because\r\n                    // String.fromCharCode(65536) == String.fromCharCode(0)\r\n                    line = text.substring(lineStart);\r\n                    lineEnd = text.length;\r\n                }\r\n                chars += String.fromCharCode(lineArrayLength);\r\n                lineHash[line] = lineArrayLength;\r\n                lineArray[lineArrayLength++] = line;\r\n            }\r\n            lineStart = lineEnd + 1;\r\n        }\r\n        return chars;\r\n    }\r\n    // Allocate 2/3rds of the space for text1, the rest for text2.\r\n    var maxLines = 40000;\r\n    var chars1 = diff_linesToCharsMunge_(text1);\r\n    maxLines = 65535;\r\n    var chars2 = diff_linesToCharsMunge_(text2);\r\n    return { chars1: chars1, chars2: chars2, lineArray: lineArray };\r\n};\r\n\r\n// ADDED MANUALLY\r\ndiff_match_patch.prototype.diff_linesToWords_ = function (text1, text2) {\r\n    var lineArray = [];  // e.g. lineArray[4] == 'Hello\\n'\r\n    var lineHash = {};   // e.g. lineHash['Hello\\n'] == 4\r\n\r\n    // '\\x00' is a valid character, but various debuggers don't like it.\r\n    // So we'll insert a junk entry to avoid generating a null character.\r\n    lineArray[0] = '';\r\n\r\n    /**\r\n     * Split a text into an array of strings.  Reduce the texts to a string of\r\n     * hashes where each Unicode character represents one word.\r\n     * Modifies linearray and linehash through being a closure.\r\n     * @param {string} text String to encode.\r\n     * @return {string} Encoded string.\r\n     * @private\r\n     */\r\n    function diff_linesToCharsMunge_(text) {\r\n        var chars = '';\r\n        // Walk the text, pulling out a substring for each line.\r\n        // text.split('\\n') would would temporarily double our memory footprint.\r\n        // Modifying text would create many large strings to garbage collect.\r\n        var lineStart = 0;\r\n        var lineEnd = -1;\r\n        // Keeping our own length variable is faster than looking it up.\r\n        var lineArrayLength = lineArray.length;\r\n        while (lineEnd < text.length - 1) {\r\n            lineEnd = text.indexOf(' ', lineStart);\r\n            if (lineEnd == -1) {\r\n                lineEnd = text.length - 1;\r\n            }\r\n            var line = text.substring(lineStart, lineEnd + 1);\r\n\r\n            if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :\r\n                (lineHash[line] !== undefined)) {\r\n                chars += String.fromCharCode(lineHash[line]);\r\n            } else {\r\n                if (lineArrayLength == maxLines) {\r\n                    // Bail out at 65535 because\r\n                    // String.fromCharCode(65536) == String.fromCharCode(0)\r\n                    line = text.substring(lineStart);\r\n                    lineEnd = text.length;\r\n                }\r\n                chars += String.fromCharCode(lineArrayLength);\r\n                lineHash[line] = lineArrayLength;\r\n                lineArray[lineArrayLength++] = line;\r\n            }\r\n            lineStart = lineEnd + 1;\r\n        }\r\n        return chars;\r\n    }\r\n    // Allocate 2/3rds of the space for text1, the rest for text2.\r\n    var maxLines = 40000;\r\n    var chars1 = diff_linesToCharsMunge_(text1);\r\n    maxLines = 65535;\r\n    var chars2 = diff_linesToCharsMunge_(text2);\r\n    return { chars1: chars1, chars2: chars2, lineArray: lineArray };\r\n};\r\n\r\n\r\n/**\r\n * Rehydrate the text in a diff from a string of line hashes to real lines of\r\n * text.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n * @param {!Array.<string>} lineArray Array of unique strings.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_charsToLines_ = function (diffs, lineArray) {\r\n    for (var i = 0; i < diffs.length; i++) {\r\n        var chars = diffs[i][1];\r\n        var text = [];\r\n        for (var j = 0; j < chars.length; j++) {\r\n            text[j] = lineArray[chars.charCodeAt(j)];\r\n        }\r\n        diffs[i][1] = text.join('');\r\n    }\r\n};\r\n\r\n\r\n/**\r\n * Determine the common prefix of two strings.\r\n * @param {string} text1 First string.\r\n * @param {string} text2 Second string.\r\n * @return {number} The number of characters common to the start of each\r\n *     string.\r\n */\r\ndiff_match_patch.prototype.diff_commonPrefix = function (text1, text2) {\r\n    // Quick check for common null cases.\r\n    if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {\r\n        return 0;\r\n    }\r\n    // Binary search.\r\n    // Performance analysis: https://neil.fraser.name/news/2007/10/09/\r\n    var pointermin = 0;\r\n    var pointermax = Math.min(text1.length, text2.length);\r\n    var pointermid = pointermax;\r\n    var pointerstart = 0;\r\n    while (pointermin < pointermid) {\r\n        if (text1.substring(pointerstart, pointermid) ==\r\n            text2.substring(pointerstart, pointermid)) {\r\n            pointermin = pointermid;\r\n            pointerstart = pointermin;\r\n        } else {\r\n            pointermax = pointermid;\r\n        }\r\n        pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\r\n    }\r\n    return pointermid;\r\n};\r\n\r\n\r\n/**\r\n * Determine the common suffix of two strings.\r\n * @param {string} text1 First string.\r\n * @param {string} text2 Second string.\r\n * @return {number} The number of characters common to the end of each string.\r\n */\r\ndiff_match_patch.prototype.diff_commonSuffix = function (text1, text2) {\r\n    // Quick check for common null cases.\r\n    if (!text1 || !text2 ||\r\n        text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {\r\n        return 0;\r\n    }\r\n    // Binary search.\r\n    // Performance analysis: https://neil.fraser.name/news/2007/10/09/\r\n    var pointermin = 0;\r\n    var pointermax = Math.min(text1.length, text2.length);\r\n    var pointermid = pointermax;\r\n    var pointerend = 0;\r\n    while (pointermin < pointermid) {\r\n        if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==\r\n            text2.substring(text2.length - pointermid, text2.length - pointerend)) {\r\n            pointermin = pointermid;\r\n            pointerend = pointermin;\r\n        } else {\r\n            pointermax = pointermid;\r\n        }\r\n        pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\r\n    }\r\n    return pointermid;\r\n};\r\n\r\n\r\n/**\r\n * Determine if the suffix of one string is the prefix of another.\r\n * @param {string} text1 First string.\r\n * @param {string} text2 Second string.\r\n * @return {number} The number of characters common to the end of the first\r\n *     string and the start of the second string.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_commonOverlap_ = function (text1, text2) {\r\n    // Cache the text lengths to prevent multiple calls.\r\n    var text1_length = text1.length;\r\n    var text2_length = text2.length;\r\n    // Eliminate the null case.\r\n    if (text1_length == 0 || text2_length == 0) {\r\n        return 0;\r\n    }\r\n    // Truncate the longer string.\r\n    if (text1_length > text2_length) {\r\n        text1 = text1.substring(text1_length - text2_length);\r\n    } else if (text1_length < text2_length) {\r\n        text2 = text2.substring(0, text1_length);\r\n    }\r\n    var text_length = Math.min(text1_length, text2_length);\r\n    // Quick check for the worst case.\r\n    if (text1 == text2) {\r\n        return text_length;\r\n    }\r\n\r\n    // Start by looking for a single character match\r\n    // and increase length until no match is found.\r\n    // Performance analysis: https://neil.fraser.name/news/2010/11/04/\r\n    var best = 0;\r\n    var length = 1;\r\n    while (true) {\r\n        var pattern = text1.substring(text_length - length);\r\n        var found = text2.indexOf(pattern);\r\n        if (found == -1) {\r\n            return best;\r\n        }\r\n        length += found;\r\n        if (found == 0 || text1.substring(text_length - length) ==\r\n            text2.substring(0, length)) {\r\n            best = length;\r\n            length++;\r\n        }\r\n    }\r\n};\r\n\r\n\r\n/**\r\n * Do the two texts share a substring which is at least half the length of the\r\n * longer text?\r\n * This speedup can produce non-minimal diffs.\r\n * @param {string} text1 First string.\r\n * @param {string} text2 Second string.\r\n * @return {Array.<string>} Five element Array, containing the prefix of\r\n *     text1, the suffix of text1, the prefix of text2, the suffix of\r\n *     text2 and the common middle.  Or null if there was no match.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.diff_halfMatch_ = function (text1, text2) {\r\n    if (this.Diff_Timeout <= 0) {\r\n        // Don't risk returning a non-optimal diff if we have unlimited time.\r\n        return null;\r\n    }\r\n    var longtext = text1.length > text2.length ? text1 : text2;\r\n    var shorttext = text1.length > text2.length ? text2 : text1;\r\n    if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {\r\n        return null;  // Pointless.\r\n    }\r\n    var dmp = this;  // 'this' becomes 'window' in a closure.\r\n\r\n    /**\r\n     * Does a substring of shorttext exist within longtext such that the substring\r\n     * is at least half the length of longtext?\r\n     * Closure, but does not reference any external variables.\r\n     * @param {string} longtext Longer string.\r\n     * @param {string} shorttext Shorter string.\r\n     * @param {number} i Start index of quarter length substring within longtext.\r\n     * @return {Array.<string>} Five element Array, containing the prefix of\r\n     *     longtext, the suffix of longtext, the prefix of shorttext, the suffix\r\n     *     of shorttext and the common middle.  Or null if there was no match.\r\n     * @private\r\n     */\r\n    function diff_halfMatchI_(longtext, shorttext, i) {\r\n        // Start with a 1/4 length substring at position i as a seed.\r\n        var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\r\n        var j = -1;\r\n        var best_common = '';\r\n        var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\r\n        while ((j = shorttext.indexOf(seed, j + 1)) != -1) {\r\n            var prefixLength = dmp.diff_commonPrefix(longtext.substring(i),\r\n                shorttext.substring(j));\r\n            var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i),\r\n                shorttext.substring(0, j));\r\n            if (best_common.length < suffixLength + prefixLength) {\r\n                best_common = shorttext.substring(j - suffixLength, j) +\r\n                    shorttext.substring(j, j + prefixLength);\r\n                best_longtext_a = longtext.substring(0, i - suffixLength);\r\n                best_longtext_b = longtext.substring(i + prefixLength);\r\n                best_shorttext_a = shorttext.substring(0, j - suffixLength);\r\n                best_shorttext_b = shorttext.substring(j + prefixLength);\r\n            }\r\n        }\r\n        if (best_common.length * 2 >= longtext.length) {\r\n            return [best_longtext_a, best_longtext_b,\r\n                best_shorttext_a, best_shorttext_b, best_common];\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    // First check if the second quarter is the seed for a half-match.\r\n    var hm1 = diff_halfMatchI_(longtext, shorttext,\r\n        Math.ceil(longtext.length / 4));\r\n    // Check again based on the third quarter.\r\n    var hm2 = diff_halfMatchI_(longtext, shorttext,\r\n        Math.ceil(longtext.length / 2));\r\n    var hm;\r\n    if (!hm1 && !hm2) {\r\n        return null;\r\n    } else if (!hm2) {\r\n        hm = hm1;\r\n    } else if (!hm1) {\r\n        hm = hm2;\r\n    } else {\r\n        // Both matched.  Select the longest.\r\n        hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\r\n    }\r\n\r\n    // A half-match was found, sort out the return data.\r\n    var text1_a, text1_b, text2_a, text2_b;\r\n    if (text1.length > text2.length) {\r\n        text1_a = hm[0];\r\n        text1_b = hm[1];\r\n        text2_a = hm[2];\r\n        text2_b = hm[3];\r\n    } else {\r\n        text2_a = hm[0];\r\n        text2_b = hm[1];\r\n        text1_a = hm[2];\r\n        text1_b = hm[3];\r\n    }\r\n    var mid_common = hm[4];\r\n    return [text1_a, text1_b, text2_a, text2_b, mid_common];\r\n};\r\n\r\n// ADDED.\r\ndiff_match_patch.prototype.diff_cleanupBlankValues = function (diffs) {\r\n    \r\n    // Loop through each of the diffs.\r\n    for (var i = 0; i < diffs.length; i++) {\r\n\r\n        // If this is a blank value, or a space, remove it.\r\n        if (diffs[i][1].length == 0 || diffs[i][1] == \" \") {\r\n            diffs.splice(i, 1);\r\n            i--;\r\n        }\r\n\t}\r\n}\r\n\r\n// ADDED.\r\ndiff_match_patch.prototype.diff_cleanupBlankValuesCharacters = function (diffs) {\r\n    \r\n    // Loop through each of the diffs.\r\n    for (var i = 0; i < diffs.length; i++) {\r\n\r\n        // If this is a blank value, remove it.\r\n        if (diffs[i][1].length == 0) {\r\n            diffs.splice(i, 1);\r\n            i--;\r\n        }\r\n        // If this is a space, make this a substitution with a character from either side.\r\n        else if (diffs[i][1] == \" \") {\r\n\r\n            // Check if we are able to successfully sub out the space.\r\n            var spaceSubbed = false;\r\n\r\n            // If we have a no difference before with multiple characters, move the character from the end into this empty difference.\r\n            if (i > 0 && diffs[i - 1][0] == 0 && diffs[i - 1][1].length > 1) {\r\n                diffs[i][1] = diffs[i - 1][1].substring(diffs[i - 1][1].length - 1, diffs[i - 1][1].length) + diffs[i][1];\r\n                diffs[i - 1][1] = diffs[i - 1][1].substring(0, diffs[i - 1][1].length - 1);\r\n                spaceSubbed = true;\r\n\t\t\t}\r\n\r\n            // If we have a no difference after with multiple characters, move the character from the start into this empty difference.\r\n            if (i < diffs.length - 1 && diffs[i + 1][0] == 0 && diffs[i + 1][1].length > 1) {\r\n                diffs[i][1] = diffs[i][1] + diffs[i + 1][1].substring(0, 1);\r\n                diffs[i + 1][1] = diffs[i + 1][1].substring(1, diffs[i + 1][1].length);\r\n                spaceSubbed = true;\r\n            }\r\n\r\n            // If this is a deletion, add an addition without the space after the difference, so this becomes a substitution.\r\n            if (spaceSubbed && diffs[i][0] == -1) {\r\n                diffs.splice(i + 1, 0, { 0: 1, 1: diffs[i][1].replace(\" \", \"\") });\r\n            }\r\n            // If this is an addition, add a deletion without the space before the difference, so this becomes a substitution.\r\n            else if (spaceSubbed && diffs[i][0] == 1) {\r\n                diffs.splice(i, 0, { 0: -1, 1: diffs[i][1].replace(\" \", \"\") });\r\n            }\r\n\r\n            // If we failed to sub the space, simply ignore it.\r\n            if (!spaceSubbed) {\r\n                diffs.splice(i, 1);\r\n                i--;\r\n\t\t\t}\r\n\t\t}\r\n    }\r\n}\r\n\r\n/**\r\n * Reduce the number of edits by eliminating semantically trivial equalities.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n */\r\ndiff_match_patch.prototype.diff_cleanupSemantic = function (diffs) {\r\n    var changes = false;\r\n    var equalities = [];  // Stack of indices where equalities are found.\r\n    var equalitiesLength = 0;  // Keeping our own length var is faster in JS.\r\n    /** @type {?string} */\r\n    var lastEquality = null;\r\n    // Always equal to diffs[equalities[equalitiesLength - 1]][1]\r\n    var pointer = 0;  // Index of current position.\r\n    // Number of characters that changed prior to the equality.\r\n    var length_insertions1 = 0;\r\n    var length_deletions1 = 0;\r\n    // Number of characters that changed after the equality.\r\n    var length_insertions2 = 0;\r\n    var length_deletions2 = 0;\r\n    while (pointer < diffs.length) {\r\n        if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.\r\n            equalities[equalitiesLength++] = pointer;\r\n            length_insertions1 = length_insertions2;\r\n            length_deletions1 = length_deletions2;\r\n            length_insertions2 = 0;\r\n            length_deletions2 = 0;\r\n            lastEquality = diffs[pointer][1];\r\n        } else {  // An insertion or deletion.\r\n            if (diffs[pointer][0] == DIFF_INSERT) {\r\n                length_insertions2 += diffs[pointer][1].length;\r\n            } else {\r\n                length_deletions2 += diffs[pointer][1].length;\r\n            }\r\n            // Eliminate an equality that is smaller or equal to the edits on both\r\n            // sides of it.\r\n            if (lastEquality && (lastEquality.length <=\r\n                Math.max(length_insertions1, length_deletions1)) &&\r\n                (lastEquality.length <= Math.max(length_insertions2,\r\n                    length_deletions2))) {\r\n                // Duplicate record.\r\n                diffs.splice(equalities[equalitiesLength - 1], 0,\r\n                    new diff_match_patch.Diff(DIFF_DELETE, lastEquality));\r\n                // Change second copy to insert.\r\n                diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\r\n                // Throw away the equality we just deleted.\r\n                equalitiesLength--;\r\n                // Throw away the previous equality (it needs to be reevaluated).\r\n                equalitiesLength--;\r\n                pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\r\n                length_insertions1 = 0;  // Reset the counters.\r\n                length_deletions1 = 0;\r\n                length_insertions2 = 0;\r\n                length_deletions2 = 0;\r\n                lastEquality = null;\r\n                changes = true;\r\n            }\r\n        }\r\n        pointer++;\r\n    }\r\n\r\n    // Normalize the diff.\r\n    if (changes) {\r\n        this.diff_cleanupMerge(diffs);\r\n    }\r\n    this.diff_cleanupSemanticLossless(diffs);\r\n\r\n    // Find any overlaps between deletions and insertions.\r\n    // e.g: <del>abcxxx</del><ins>xxxdef</ins>\r\n    //   -> <del>abc</del>xxx<ins>def</ins>\r\n    // e.g: <del>xxxabc</del><ins>defxxx</ins>\r\n    //   -> <ins>def</ins>xxx<del>abc</del>\r\n    // Only extract an overlap if it is as big as the edit ahead or behind it.\r\n    pointer = 1;\r\n    while (pointer < diffs.length) {\r\n        if (diffs[pointer - 1][0] == DIFF_DELETE &&\r\n            diffs[pointer][0] == DIFF_INSERT) {\r\n            var deletion = diffs[pointer - 1][1];\r\n            var insertion = diffs[pointer][1];\r\n            var overlap_length1 = this.diff_commonOverlap_(deletion, insertion);\r\n            var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);\r\n            if (overlap_length1 >= overlap_length2) {\r\n                if (overlap_length1 >= deletion.length / 2 ||\r\n                    overlap_length1 >= insertion.length / 2) {\r\n                    // Overlap found.  Insert an equality and trim the surrounding edits.\r\n                    diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\r\n                        insertion.substring(0, overlap_length1)));\r\n                    diffs[pointer - 1][1] =\r\n                        deletion.substring(0, deletion.length - overlap_length1);\r\n                    diffs[pointer + 1][1] = insertion.substring(overlap_length1);\r\n                    pointer++;\r\n                }\r\n            } else {\r\n                if (overlap_length2 >= deletion.length / 2 ||\r\n                    overlap_length2 >= insertion.length / 2) {\r\n                    // Reverse overlap found.\r\n                    // Insert an equality and swap and trim the surrounding edits.\r\n                    diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\r\n                        deletion.substring(0, overlap_length2)));\r\n                    diffs[pointer - 1][0] = DIFF_INSERT;\r\n                    diffs[pointer - 1][1] =\r\n                        insertion.substring(0, insertion.length - overlap_length2);\r\n                    diffs[pointer + 1][0] = DIFF_DELETE;\r\n                    diffs[pointer + 1][1] =\r\n                        deletion.substring(overlap_length2);\r\n                    pointer++;\r\n                }\r\n            }\r\n            pointer++;\r\n        }\r\n        pointer++;\r\n    }\r\n};\r\n\r\n\r\n/**\r\n * Look for single edits surrounded on both sides by equalities\r\n * which can be shifted sideways to align the edit to a word boundary.\r\n * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n */\r\ndiff_match_patch.prototype.diff_cleanupSemanticLossless = function (diffs) {\r\n    /**\r\n     * Given two strings, compute a score representing whether the internal\r\n     * boundary falls on logical boundaries.\r\n     * Scores range from 6 (best) to 0 (worst).\r\n     * Closure, but does not reference any external variables.\r\n     * @param {string} one First string.\r\n     * @param {string} two Second string.\r\n     * @return {number} The score.\r\n     * @private\r\n     */\r\n    function diff_cleanupSemanticScore_(one, two) {\r\n        if (!one || !two) {\r\n            // Edges are the best.\r\n            return 6;\r\n        }\r\n\r\n        // Each port of this function behaves slightly differently due to\r\n        // subtle differences in each language's definition of things like\r\n        // 'whitespace'.  Since this function's purpose is largely cosmetic,\r\n        // the choice has been made to use each language's native features\r\n        // rather than force total conformity.\r\n        var char1 = one.charAt(one.length - 1);\r\n        var char2 = two.charAt(0);\r\n        var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_);\r\n        var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_);\r\n        var whitespace1 = nonAlphaNumeric1 &&\r\n            char1.match(diff_match_patch.whitespaceRegex_);\r\n        var whitespace2 = nonAlphaNumeric2 &&\r\n            char2.match(diff_match_patch.whitespaceRegex_);\r\n        var lineBreak1 = whitespace1 &&\r\n            char1.match(diff_match_patch.linebreakRegex_);\r\n        var lineBreak2 = whitespace2 &&\r\n            char2.match(diff_match_patch.linebreakRegex_);\r\n        var blankLine1 = lineBreak1 &&\r\n            one.match(diff_match_patch.blanklineEndRegex_);\r\n        var blankLine2 = lineBreak2 &&\r\n            two.match(diff_match_patch.blanklineStartRegex_);\r\n\r\n        if (blankLine1 || blankLine2) {\r\n            // Five points for blank lines.\r\n            return 5;\r\n        } else if (lineBreak1 || lineBreak2) {\r\n            // Four points for line breaks.\r\n            return 4;\r\n        } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\r\n            // Three points for end of sentences.\r\n            return 3;\r\n        } else if (whitespace1 || whitespace2) {\r\n            // Two points for whitespace.\r\n            return 2;\r\n        } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\r\n            // One point for non-alphanumeric.\r\n            return 1;\r\n        }\r\n        return 0;\r\n    }\r\n\r\n    var pointer = 1;\r\n    // Intentionally ignore the first and last element (don't need checking).\r\n    while (pointer < diffs.length - 1) {\r\n        if (diffs[pointer - 1][0] == DIFF_EQUAL &&\r\n            diffs[pointer + 1][0] == DIFF_EQUAL) {\r\n            // This is a single edit surrounded by equalities.\r\n            var equality1 = diffs[pointer - 1][1];\r\n            var edit = diffs[pointer][1];\r\n            var equality2 = diffs[pointer + 1][1];\r\n\r\n            // First, shift the edit as far left as possible.\r\n            var commonOffset = this.diff_commonSuffix(equality1, edit);\r\n            if (commonOffset) {\r\n                var commonString = edit.substring(edit.length - commonOffset);\r\n                equality1 = equality1.substring(0, equality1.length - commonOffset);\r\n                edit = commonString + edit.substring(0, edit.length - commonOffset);\r\n                equality2 = commonString + equality2;\r\n            }\r\n\r\n            // Second, step character by character right, looking for the best fit.\r\n            var bestEquality1 = equality1;\r\n            var bestEdit = edit;\r\n            var bestEquality2 = equality2;\r\n            var bestScore = diff_cleanupSemanticScore_(equality1, edit) +\r\n                diff_cleanupSemanticScore_(edit, equality2);\r\n            while (edit.charAt(0) === equality2.charAt(0)) {\r\n                equality1 += edit.charAt(0);\r\n                edit = edit.substring(1) + equality2.charAt(0);\r\n                equality2 = equality2.substring(1);\r\n                var score = diff_cleanupSemanticScore_(equality1, edit) +\r\n                    diff_cleanupSemanticScore_(edit, equality2);\r\n                // The >= encourages trailing rather than leading whitespace on edits.\r\n                if (score >= bestScore) {\r\n                    bestScore = score;\r\n                    bestEquality1 = equality1;\r\n                    bestEdit = edit;\r\n                    bestEquality2 = equality2;\r\n                }\r\n            }\r\n\r\n            if (diffs[pointer - 1][1] != bestEquality1) {\r\n                // We have an improvement, save it back to the diff.\r\n                if (bestEquality1) {\r\n                    diffs[pointer - 1][1] = bestEquality1;\r\n                } else {\r\n                    diffs.splice(pointer - 1, 1);\r\n                    pointer--;\r\n                }\r\n                diffs[pointer][1] = bestEdit;\r\n                if (bestEquality2) {\r\n                    diffs[pointer + 1][1] = bestEquality2;\r\n                } else {\r\n                    diffs.splice(pointer + 1, 1);\r\n                    pointer--;\r\n                }\r\n            }\r\n        }\r\n        pointer++;\r\n    }\r\n};\r\n\r\n// Define some regex patterns for matching boundaries.\r\ndiff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\r\ndiff_match_patch.whitespaceRegex_ = /\\s/;\r\ndiff_match_patch.linebreakRegex_ = /[\\r\\n]/;\r\ndiff_match_patch.blanklineEndRegex_ = /\\n\\r?\\n$/;\r\ndiff_match_patch.blanklineStartRegex_ = /^\\r?\\n\\r?\\n/;\r\n\r\n/**\r\n * Reduce the number of edits by eliminating operationally trivial equalities.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n */\r\ndiff_match_patch.prototype.diff_cleanupEfficiency = function (diffs) {\r\n    var changes = false;\r\n    var equalities = [];  // Stack of indices where equalities are found.\r\n    var equalitiesLength = 0;  // Keeping our own length var is faster in JS.\r\n    /** @type {?string} */\r\n    var lastEquality = null;\r\n    // Always equal to diffs[equalities[equalitiesLength - 1]][1]\r\n    var pointer = 0;  // Index of current position.\r\n    // Is there an insertion operation before the last equality.\r\n    var pre_ins = false;\r\n    // Is there a deletion operation before the last equality.\r\n    var pre_del = false;\r\n    // Is there an insertion operation after the last equality.\r\n    var post_ins = false;\r\n    // Is there a deletion operation after the last equality.\r\n    var post_del = false;\r\n    while (pointer < diffs.length) {\r\n        if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.\r\n            if (diffs[pointer][1].length < this.Diff_EditCost &&\r\n                (post_ins || post_del)) {\r\n                // Candidate found.\r\n                equalities[equalitiesLength++] = pointer;\r\n                pre_ins = post_ins;\r\n                pre_del = post_del;\r\n                lastEquality = diffs[pointer][1];\r\n            } else {\r\n                // Not a candidate, and can never become one.\r\n                equalitiesLength = 0;\r\n                lastEquality = null;\r\n            }\r\n            post_ins = post_del = false;\r\n        } else {  // An insertion or deletion.\r\n            if (diffs[pointer][0] == DIFF_DELETE) {\r\n                post_del = true;\r\n            } else {\r\n                post_ins = true;\r\n            }\r\n            /*\r\n             * Five types to be split:\r\n             * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>\r\n             * <ins>A</ins>X<ins>C</ins><del>D</del>\r\n             * <ins>A</ins><del>B</del>X<ins>C</ins>\r\n             * <ins>A</del>X<ins>C</ins><del>D</del>\r\n             * <ins>A</ins><del>B</del>X<del>C</del>\r\n             */\r\n            if (lastEquality && ((pre_ins && pre_del && post_ins && post_del) ||\r\n                ((lastEquality.length < this.Diff_EditCost / 2) &&\r\n                    (pre_ins + pre_del + post_ins + post_del) == 3))) {\r\n                // Duplicate record.\r\n                diffs.splice(equalities[equalitiesLength - 1], 0,\r\n                    new diff_match_patch.Diff(DIFF_DELETE, lastEquality));\r\n                // Change second copy to insert.\r\n                diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\r\n                equalitiesLength--;  // Throw away the equality we just deleted;\r\n                lastEquality = null;\r\n                if (pre_ins && pre_del) {\r\n                    // No changes made which could affect previous entry, keep going.\r\n                    post_ins = post_del = true;\r\n                    equalitiesLength = 0;\r\n                } else {\r\n                    equalitiesLength--;  // Throw away the previous equality.\r\n                    pointer = equalitiesLength > 0 ?\r\n                        equalities[equalitiesLength - 1] : -1;\r\n                    post_ins = post_del = false;\r\n                }\r\n                changes = true;\r\n            }\r\n        }\r\n        pointer++;\r\n    }\r\n\r\n    if (changes) {\r\n        this.diff_cleanupMerge(diffs);\r\n    }\r\n};\r\n\r\n\r\n/**\r\n * Reorder and merge like edit sections.  Merge equalities.\r\n * Any edit section can move as long as it doesn't cross an equality.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n */\r\ndiff_match_patch.prototype.diff_cleanupMerge = function (diffs) {\r\n    // Add a dummy entry at the end.\r\n    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));\r\n    var pointer = 0;\r\n    var count_delete = 0;\r\n    var count_insert = 0;\r\n    var text_delete = '';\r\n    var text_insert = '';\r\n    var commonlength;\r\n    while (pointer < diffs.length) {\r\n        switch (diffs[pointer][0]) {\r\n            case DIFF_INSERT:\r\n                count_insert++;\r\n                text_insert += diffs[pointer][1];\r\n                pointer++;\r\n                break;\r\n            case DIFF_DELETE:\r\n                count_delete++;\r\n                text_delete += diffs[pointer][1];\r\n                pointer++;\r\n                break;\r\n            case DIFF_EQUAL:\r\n                // Upon reaching an equality, check for prior redundancies.\r\n                if (count_delete + count_insert > 1) {\r\n                    if (count_delete !== 0 && count_insert !== 0) {\r\n                        // Factor out any common prefixies.\r\n                        commonlength = this.diff_commonPrefix(text_insert, text_delete);\r\n                        if (commonlength !== 0) {\r\n                            if ((pointer - count_delete - count_insert) > 0 &&\r\n                                diffs[pointer - count_delete - count_insert - 1][0] ==\r\n                                DIFF_EQUAL) {\r\n                                diffs[pointer - count_delete - count_insert - 1][1] +=\r\n                                    text_insert.substring(0, commonlength);\r\n                            } else {\r\n                                diffs.splice(0, 0, new diff_match_patch.Diff(DIFF_EQUAL,\r\n                                    text_insert.substring(0, commonlength)));\r\n                                pointer++;\r\n                            }\r\n                            text_insert = text_insert.substring(commonlength);\r\n                            text_delete = text_delete.substring(commonlength);\r\n                        }\r\n                        // Factor out any common suffixies.\r\n                        commonlength = this.diff_commonSuffix(text_insert, text_delete);\r\n                        if (commonlength !== 0) {\r\n                            diffs[pointer][1] = text_insert.substring(text_insert.length -\r\n                                commonlength) + diffs[pointer][1];\r\n                            text_insert = text_insert.substring(0, text_insert.length -\r\n                                commonlength);\r\n                            text_delete = text_delete.substring(0, text_delete.length -\r\n                                commonlength);\r\n                        }\r\n                    }\r\n                    // Delete the offending records and add the merged ones.\r\n                    pointer -= count_delete + count_insert;\r\n                    diffs.splice(pointer, count_delete + count_insert);\r\n                    if (text_delete.length) {\r\n                        diffs.splice(pointer, 0,\r\n                            new diff_match_patch.Diff(DIFF_DELETE, text_delete));\r\n                        pointer++;\r\n                    }\r\n                    if (text_insert.length) {\r\n                        diffs.splice(pointer, 0,\r\n                            new diff_match_patch.Diff(DIFF_INSERT, text_insert));\r\n                        pointer++;\r\n                    }\r\n                    pointer++;\r\n                } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {\r\n                    // Merge this equality with the previous one.\r\n                    diffs[pointer - 1][1] += diffs[pointer][1];\r\n                    diffs.splice(pointer, 1);\r\n                } else {\r\n                    pointer++;\r\n                }\r\n                count_insert = 0;\r\n                count_delete = 0;\r\n                text_delete = '';\r\n                text_insert = '';\r\n                break;\r\n        }\r\n    }\r\n    if (diffs[diffs.length - 1][1] === '') {\r\n        diffs.pop();  // Remove the dummy entry at the end.\r\n    }\r\n\r\n    // Second pass: look for single edits surrounded on both sides by equalities\r\n    // which can be shifted sideways to eliminate an equality.\r\n    // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC\r\n    var changes = false;\r\n    pointer = 1;\r\n    // Intentionally ignore the first and last element (don't need checking).\r\n    while (pointer < diffs.length - 1) {\r\n        if (diffs[pointer - 1][0] == DIFF_EQUAL &&\r\n            diffs[pointer + 1][0] == DIFF_EQUAL) {\r\n            // This is a single edit surrounded by equalities.\r\n            if (diffs[pointer][1].substring(diffs[pointer][1].length -\r\n                diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {\r\n                // Shift the edit over the previous equality.\r\n                diffs[pointer][1] = diffs[pointer - 1][1] +\r\n                    diffs[pointer][1].substring(0, diffs[pointer][1].length -\r\n                        diffs[pointer - 1][1].length);\r\n                diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\r\n                diffs.splice(pointer - 1, 1);\r\n                changes = true;\r\n            } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\r\n                diffs[pointer + 1][1]) {\r\n                // Shift the edit over the next equality.\r\n                diffs[pointer - 1][1] += diffs[pointer + 1][1];\r\n                diffs[pointer][1] =\r\n                    diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\r\n                    diffs[pointer + 1][1];\r\n                diffs.splice(pointer + 1, 1);\r\n                changes = true;\r\n            }\r\n        }\r\n        pointer++;\r\n    }\r\n    // If shifts were made, the diff needs reordering and another shift sweep.\r\n    if (changes) {\r\n        this.diff_cleanupMerge(diffs);\r\n    }\r\n};\r\n\r\n\r\n/**\r\n * loc is a location in text1, compute and return the equivalent location in\r\n * text2.\r\n * e.g. 'The cat' vs 'The big cat', 1->1, 5->8\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n * @param {number} loc Location within text1.\r\n * @return {number} Location within text2.\r\n */\r\ndiff_match_patch.prototype.diff_xIndex = function (diffs, loc) {\r\n    var chars1 = 0;\r\n    var chars2 = 0;\r\n    var last_chars1 = 0;\r\n    var last_chars2 = 0;\r\n    var x;\r\n    for (x = 0; x < diffs.length; x++) {\r\n        if (diffs[x][0] !== DIFF_INSERT) {  // Equality or deletion.\r\n            chars1 += diffs[x][1].length;\r\n        }\r\n        if (diffs[x][0] !== DIFF_DELETE) {  // Equality or insertion.\r\n            chars2 += diffs[x][1].length;\r\n        }\r\n        if (chars1 > loc) {  // Overshot the location.\r\n            break;\r\n        }\r\n        last_chars1 = chars1;\r\n        last_chars2 = chars2;\r\n    }\r\n    // Was the location was deleted?\r\n    if (diffs.length != x && diffs[x][0] === DIFF_DELETE) {\r\n        return last_chars2;\r\n    }\r\n    // Add the remaining character length.\r\n    return last_chars2 + (loc - last_chars1);\r\n};\r\n\r\n\r\n/**\r\n * Convert a diff array into a pretty HTML report.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n * @return {string} HTML representation.\r\n */\r\ndiff_match_patch.prototype.diff_prettyHtml = function (diffs) {\r\n    var html = [];\r\n    var pattern_amp = /&/g;\r\n    var pattern_lt = /</g;\r\n    var pattern_gt = />/g;\r\n    var pattern_para = /\\n/g;\r\n    for (var x = 0; x < diffs.length; x++) {\r\n        var op = diffs[x][0];    // Operation (insert, delete, equal)\r\n        var data = diffs[x][1];  // Text of change.\r\n        var text = data.replace(pattern_amp, '&amp;').replace(pattern_lt, '&lt;')\r\n            .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');\r\n        switch (op) {\r\n            case DIFF_INSERT:\r\n                html[x] = '<ins style=\"background:#e6ffe6;\">' + text + '</ins>';\r\n                break;\r\n            case DIFF_DELETE:\r\n                html[x] = '<del style=\"background:#ffe6e6;\">' + text + '</del>';\r\n                break;\r\n            case DIFF_EQUAL:\r\n                html[x] = '<span>' + text + '</span>';\r\n                break;\r\n        }\r\n    }\r\n    return html.join('');\r\n};\r\n\r\n\r\n/**\r\n * Compute and return the source text (all equalities and deletions).\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n * @return {string} Source text.\r\n */\r\ndiff_match_patch.prototype.diff_text1 = function (diffs) {\r\n    var text = [];\r\n    for (var x = 0; x < diffs.length; x++) {\r\n        if (diffs[x][0] !== DIFF_INSERT) {\r\n            text[x] = diffs[x][1];\r\n        }\r\n    }\r\n    return text.join('');\r\n};\r\n\r\n\r\n/**\r\n * Compute and return the destination text (all equalities and insertions).\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n * @return {string} Destination text.\r\n */\r\ndiff_match_patch.prototype.diff_text2 = function (diffs) {\r\n    var text = [];\r\n    for (var x = 0; x < diffs.length; x++) {\r\n        if (diffs[x][0] !== DIFF_DELETE) {\r\n            text[x] = diffs[x][1];\r\n        }\r\n    }\r\n    return text.join('');\r\n};\r\n\r\n\r\n/**\r\n * Compute the Levenshtein distance; the number of inserted, deleted or\r\n * substituted characters.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n * @return {number} Number of changes.\r\n */\r\ndiff_match_patch.prototype.diff_levenshtein = function (diffs) {\r\n    var levenshtein = 0;\r\n    var insertions = 0;\r\n    var deletions = 0;\r\n    for (var x = 0; x < diffs.length; x++) {\r\n        var op = diffs[x][0];\r\n        var data = diffs[x][1];\r\n        switch (op) {\r\n            case DIFF_INSERT:\r\n                insertions += data.length;\r\n                break;\r\n            case DIFF_DELETE:\r\n                deletions += data.length;\r\n                break;\r\n            case DIFF_EQUAL:\r\n                // A deletion and an insertion is one substitution.\r\n                levenshtein += Math.max(insertions, deletions);\r\n                insertions = 0;\r\n                deletions = 0;\r\n                break;\r\n        }\r\n    }\r\n    levenshtein += Math.max(insertions, deletions);\r\n    return levenshtein;\r\n};\r\n\r\n\r\n/**\r\n * Crush the diff into an encoded string which describes the operations\r\n * required to transform text1 into text2.\r\n * E.g. =3\\t-2\\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.\r\n * Operations are tab-separated.  Inserted text is escaped using %xx notation.\r\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\r\n * @return {string} Delta text.\r\n */\r\ndiff_match_patch.prototype.diff_toDelta = function (diffs) {\r\n    var text = [];\r\n    for (var x = 0; x < diffs.length; x++) {\r\n        switch (diffs[x][0]) {\r\n            case DIFF_INSERT:\r\n                text[x] = '+' + encodeURI(diffs[x][1]);\r\n                break;\r\n            case DIFF_DELETE:\r\n                text[x] = '-' + diffs[x][1].length;\r\n                break;\r\n            case DIFF_EQUAL:\r\n                text[x] = '=' + diffs[x][1].length;\r\n                break;\r\n        }\r\n    }\r\n    return text.join('\\t').replace(/%20/g, ' ');\r\n};\r\n\r\n\r\n/**\r\n * Given the original text1, and an encoded string which describes the\r\n * operations required to transform text1 into text2, compute the full diff.\r\n * @param {string} text1 Source string for the diff.\r\n * @param {string} delta Delta text.\r\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\r\n * @throws {!Error} If invalid input.\r\n */\r\ndiff_match_patch.prototype.diff_fromDelta = function (text1, delta) {\r\n    var diffs = [];\r\n    var diffsLength = 0;  // Keeping our own length var is faster in JS.\r\n    var pointer = 0;  // Cursor in text1\r\n    var tokens = delta.split(/\\t/g);\r\n    for (var x = 0; x < tokens.length; x++) {\r\n        // Each token begins with a one character parameter which specifies the\r\n        // operation of this token (delete, insert, equality).\r\n        var param = tokens[x].substring(1);\r\n        switch (tokens[x].charAt(0)) {\r\n            case '+':\r\n                try {\r\n                    diffs[diffsLength++] =\r\n                        new diff_match_patch.Diff(DIFF_INSERT, decodeURI(param));\r\n                } catch (ex) {\r\n                    // Malformed URI sequence.\r\n                    throw new Error('Illegal escape in diff_fromDelta: ' + param);\r\n                }\r\n                break;\r\n            case '-':\r\n            // Fall through.\r\n            case '=':\r\n                var n = parseInt(param, 10);\r\n                if (isNaN(n) || n < 0) {\r\n                    throw new Error('Invalid number in diff_fromDelta: ' + param);\r\n                }\r\n                var text = text1.substring(pointer, pointer += n);\r\n                if (tokens[x].charAt(0) == '=') {\r\n                    diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_EQUAL, text);\r\n                } else {\r\n                    diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_DELETE, text);\r\n                }\r\n                break;\r\n            default:\r\n                // Blank tokens are ok (from a trailing \\t).\r\n                // Anything else is an error.\r\n                if (tokens[x]) {\r\n                    throw new Error('Invalid diff operation in diff_fromDelta: ' +\r\n                        tokens[x]);\r\n                }\r\n        }\r\n    }\r\n    if (pointer != text1.length) {\r\n        throw new Error('Delta length (' + pointer +\r\n            ') does not equal source text length (' + text1.length + ').');\r\n    }\r\n    return diffs;\r\n};\r\n\r\n\r\n//  MATCH FUNCTIONS\r\n\r\n\r\n/**\r\n * Locate the best instance of 'pattern' in 'text' near 'loc'.\r\n * @param {string} text The text to search.\r\n * @param {string} pattern The pattern to search for.\r\n * @param {number} loc The location to search around.\r\n * @return {number} Best match index or -1.\r\n */\r\ndiff_match_patch.prototype.match_main = function (text, pattern, loc) {\r\n    // Check for null inputs.\r\n    if (text == null || pattern == null || loc == null) {\r\n        throw new Error('Null input. (match_main)');\r\n    }\r\n\r\n    loc = Math.max(0, Math.min(loc, text.length));\r\n    if (text == pattern) {\r\n        // Shortcut (potentially not guaranteed by the algorithm)\r\n        return 0;\r\n    } else if (!text.length) {\r\n        // Nothing to match.\r\n        return -1;\r\n    } else if (text.substring(loc, loc + pattern.length) == pattern) {\r\n        // Perfect match at the perfect spot!  (Includes case of null pattern)\r\n        return loc;\r\n    } else {\r\n        // Do a fuzzy compare.\r\n        return this.match_bitap_(text, pattern, loc);\r\n    }\r\n};\r\n\r\n\r\n/**\r\n * Locate the best instance of 'pattern' in 'text' near 'loc' using the\r\n * Bitap algorithm.\r\n * @param {string} text The text to search.\r\n * @param {string} pattern The pattern to search for.\r\n * @param {number} loc The location to search around.\r\n * @return {number} Best match index or -1.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.match_bitap_ = function (text, pattern, loc) {\r\n    if (pattern.length > this.Match_MaxBits) {\r\n        throw new Error('Pattern too long for this browser.');\r\n    }\r\n\r\n    // Initialise the alphabet.\r\n    var s = this.match_alphabet_(pattern);\r\n\r\n    var dmp = this;  // 'this' becomes 'window' in a closure.\r\n\r\n    /**\r\n     * Compute and return the score for a match with e errors and x location.\r\n     * Accesses loc and pattern through being a closure.\r\n     * @param {number} e Number of errors in match.\r\n     * @param {number} x Location of match.\r\n     * @return {number} Overall score for match (0.0 = good, 1.0 = bad).\r\n     * @private\r\n     */\r\n    function match_bitapScore_(e, x) {\r\n        var accuracy = e / pattern.length;\r\n        var proximity = Math.abs(loc - x);\r\n        if (!dmp.Match_Distance) {\r\n            // Dodge divide by zero error.\r\n            return proximity ? 1.0 : accuracy;\r\n        }\r\n        return accuracy + (proximity / dmp.Match_Distance);\r\n    }\r\n\r\n    // Highest score beyond which we give up.\r\n    var score_threshold = this.Match_Threshold;\r\n    // Is there a nearby exact match? (speedup)\r\n    var best_loc = text.indexOf(pattern, loc);\r\n    if (best_loc != -1) {\r\n        score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold);\r\n        // What about in the other direction? (speedup)\r\n        best_loc = text.lastIndexOf(pattern, loc + pattern.length);\r\n        if (best_loc != -1) {\r\n            score_threshold =\r\n                Math.min(match_bitapScore_(0, best_loc), score_threshold);\r\n        }\r\n    }\r\n\r\n    // Initialise the bit arrays.\r\n    var matchmask = 1 << (pattern.length - 1);\r\n    best_loc = -1;\r\n\r\n    var bin_min, bin_mid;\r\n    var bin_max = pattern.length + text.length;\r\n    var last_rd;\r\n    for (var d = 0; d < pattern.length; d++) {\r\n        // Scan for the best match; each iteration allows for one more error.\r\n        // Run a binary search to determine how far from 'loc' we can stray at this\r\n        // error level.\r\n        bin_min = 0;\r\n        bin_mid = bin_max;\r\n        while (bin_min < bin_mid) {\r\n            if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) {\r\n                bin_min = bin_mid;\r\n            } else {\r\n                bin_max = bin_mid;\r\n            }\r\n            bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);\r\n        }\r\n        // Use the result from this iteration as the maximum for the next.\r\n        bin_max = bin_mid;\r\n        var start = Math.max(1, loc - bin_mid + 1);\r\n        var finish = Math.min(loc + bin_mid, text.length) + pattern.length;\r\n\r\n        var rd = Array(finish + 2);\r\n        rd[finish + 1] = (1 << d) - 1;\r\n        for (var j = finish; j >= start; j--) {\r\n            // The alphabet (s) is a sparse hash, so the following line generates\r\n            // warnings.\r\n            var charMatch = s[text.charAt(j - 1)];\r\n            if (d === 0) {  // First pass: exact match.\r\n                rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;\r\n            } else {  // Subsequent passes: fuzzy match.\r\n                rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) |\r\n                    (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |\r\n                    last_rd[j + 1];\r\n            }\r\n            if (rd[j] & matchmask) {\r\n                var score = match_bitapScore_(d, j - 1);\r\n                // This match will almost certainly be better than any existing match.\r\n                // But check anyway.\r\n                if (score <= score_threshold) {\r\n                    // Told you so.\r\n                    score_threshold = score;\r\n                    best_loc = j - 1;\r\n                    if (best_loc > loc) {\r\n                        // When passing loc, don't exceed our current distance from loc.\r\n                        start = Math.max(1, 2 * loc - best_loc);\r\n                    } else {\r\n                        // Already passed loc, downhill from here on in.\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        // No hope for a (better) match at greater error levels.\r\n        if (match_bitapScore_(d + 1, loc) > score_threshold) {\r\n            break;\r\n        }\r\n        last_rd = rd;\r\n    }\r\n    return best_loc;\r\n};\r\n\r\n\r\n/**\r\n * Initialise the alphabet for the Bitap algorithm.\r\n * @param {string} pattern The text to encode.\r\n * @return {!Object} Hash of character locations.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.match_alphabet_ = function (pattern) {\r\n    var s = {};\r\n    for (var i = 0; i < pattern.length; i++) {\r\n        s[pattern.charAt(i)] = 0;\r\n    }\r\n    for (var i = 0; i < pattern.length; i++) {\r\n        s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);\r\n    }\r\n    return s;\r\n};\r\n\r\n\r\n//  PATCH FUNCTIONS\r\n\r\n\r\n/**\r\n * Increase the context until it is unique,\r\n * but don't let the pattern expand beyond Match_MaxBits.\r\n * @param {!diff_match_patch.patch_obj} patch The patch to grow.\r\n * @param {string} text Source text.\r\n * @private\r\n */\r\ndiff_match_patch.prototype.patch_addContext_ = function (patch, text) {\r\n    if (text.length == 0) {\r\n        return;\r\n    }\r\n    if (patch.start2 === null) {\r\n        throw Error('patch not initialized');\r\n    }\r\n    var pattern = text.substring(patch.start2, patch.start2 + patch.length1);\r\n    var padding = 0;\r\n\r\n    // Look for the first and last matches of pattern in text.  If two different\r\n    // matches are found, increase the pattern length.\r\n    while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&\r\n        pattern.length < this.Match_MaxBits - this.Patch_Margin -\r\n        this.Patch_Margin) {\r\n        padding += this.Patch_Margin;\r\n        pattern = text.substring(patch.start2 - padding,\r\n            patch.start2 + patch.length1 + padding);\r\n    }\r\n    // Add one chunk for good luck.\r\n    padding += this.Patch_Margin;\r\n\r\n    // Add the prefix.\r\n    var prefix = text.substring(patch.start2 - padding, patch.start2);\r\n    if (prefix) {\r\n        patch.diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, prefix));\r\n    }\r\n    // Add the suffix.\r\n    var suffix = text.substring(patch.start2 + patch.length1,\r\n        patch.start2 + patch.length1 + padding);\r\n    if (suffix) {\r\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, suffix));\r\n    }\r\n\r\n    // Roll back the start points.\r\n    patch.start1 -= prefix.length;\r\n    patch.start2 -= prefix.length;\r\n    // Extend the lengths.\r\n    patch.length1 += prefix.length + suffix.length;\r\n    patch.length2 += prefix.length + suffix.length;\r\n};\r\n\r\n\r\n/**\r\n * Compute a list of patches to turn text1 into text2.\r\n * Use diffs if provided, otherwise compute it ourselves.\r\n * There are four ways to call this function, depending on what data is\r\n * available to the caller:\r\n * Method 1:\r\n * a = text1, b = text2\r\n * Method 2:\r\n * a = diffs\r\n * Method 3 (optimal):\r\n * a = text1, b = diffs\r\n * Method 4 (deprecated, use method 3):\r\n * a = text1, b = text2, c = diffs\r\n *\r\n * @param {string|!Array.<!diff_match_patch.Diff>} a text1 (methods 1,3,4) or\r\n * Array of diff tuples for text1 to text2 (method 2).\r\n * @param {string|!Array.<!diff_match_patch.Diff>=} opt_b text2 (methods 1,4) or\r\n * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).\r\n * @param {string|!Array.<!diff_match_patch.Diff>=} opt_c Array of diff tuples\r\n * for text1 to text2 (method 4) or undefined (methods 1,2,3).\r\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\r\n */\r\ndiff_match_patch.prototype.patch_make = function (a, opt_b, opt_c) {\r\n    var text1, diffs;\r\n    if (typeof a == 'string' && typeof opt_b == 'string' &&\r\n        typeof opt_c == 'undefined') {\r\n        // Method 1: text1, text2\r\n        // Compute diffs from text1 and text2.\r\n        text1 = /** @type {string} */(a);\r\n        diffs = this.diff_main(text1, /** @type {string} */(opt_b), true);\r\n        if (diffs.length > 2) {\r\n            this.diff_cleanupSemantic(diffs);\r\n            this.diff_cleanupEfficiency(diffs);\r\n        }\r\n    } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' &&\r\n        typeof opt_c == 'undefined') {\r\n        // Method 2: diffs\r\n        // Compute text1 from diffs.\r\n        diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(a);\r\n        text1 = this.diff_text1(diffs);\r\n    } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' &&\r\n        typeof opt_c == 'undefined') {\r\n        // Method 3: text1, diffs\r\n        text1 = /** @type {string} */(a);\r\n        diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_b);\r\n    } else if (typeof a == 'string' && typeof opt_b == 'string' &&\r\n        opt_c && typeof opt_c == 'object') {\r\n        // Method 4: text1, text2, diffs\r\n        // text2 is not used.\r\n        text1 = /** @type {string} */(a);\r\n        diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_c);\r\n    } else {\r\n        throw new Error('Unknown call format to patch_make.');\r\n    }\r\n\r\n    if (diffs.length === 0) {\r\n        return [];  // Get rid of the null case.\r\n    }\r\n    var patches = [];\r\n    var patch = new diff_match_patch.patch_obj();\r\n    var patchDiffLength = 0;  // Keeping our own length var is faster in JS.\r\n    var char_count1 = 0;  // Number of characters into the text1 string.\r\n    var char_count2 = 0;  // Number of characters into the text2 string.\r\n    // Start with text1 (prepatch_text) and apply the diffs until we arrive at\r\n    // text2 (postpatch_text).  We recreate the patches one by one to determine\r\n    // context info.\r\n    var prepatch_text = text1;\r\n    var postpatch_text = text1;\r\n    for (var x = 0; x < diffs.length; x++) {\r\n        var diff_type = diffs[x][0];\r\n        var diff_text = diffs[x][1];\r\n\r\n        if (!patchDiffLength && diff_type !== DIFF_EQUAL) {\r\n            // A new patch starts here.\r\n            patch.start1 = char_count1;\r\n            patch.start2 = char_count2;\r\n        }\r\n\r\n        switch (diff_type) {\r\n            case DIFF_INSERT:\r\n                patch.diffs[patchDiffLength++] = diffs[x];\r\n                patch.length2 += diff_text.length;\r\n                postpatch_text = postpatch_text.substring(0, char_count2) + diff_text +\r\n                    postpatch_text.substring(char_count2);\r\n                break;\r\n            case DIFF_DELETE:\r\n                patch.length1 += diff_text.length;\r\n                patch.diffs[patchDiffLength++] = diffs[x];\r\n                postpatch_text = postpatch_text.substring(0, char_count2) +\r\n                    postpatch_text.substring(char_count2 +\r\n                        diff_text.length);\r\n                break;\r\n            case DIFF_EQUAL:\r\n                if (diff_text.length <= 2 * this.Patch_Margin &&\r\n                    patchDiffLength && diffs.length != x + 1) {\r\n                    // Small equality inside a patch.\r\n                    patch.diffs[patchDiffLength++] = diffs[x];\r\n                    patch.length1 += diff_text.length;\r\n                    patch.length2 += diff_text.length;\r\n                } else if (diff_text.length >= 2 * this.Patch_Margin) {\r\n                    // Time for a new patch.\r\n                    if (patchDiffLength) {\r\n                        this.patch_addContext_(patch, prepatch_text);\r\n                        patches.push(patch);\r\n                        patch = new diff_match_patch.patch_obj();\r\n                        patchDiffLength = 0;\r\n                        // Unlike Unidiff, our patch lists have a rolling context.\r\n                        // https://github.com/google/diff-match-patch/wiki/Unidiff\r\n                        // Update prepatch text & pos to reflect the application of the\r\n                        // just completed patch.\r\n                        prepatch_text = postpatch_text;\r\n                        char_count1 = char_count2;\r\n                    }\r\n                }\r\n                break;\r\n        }\r\n\r\n        // Update the current character count.\r\n        if (diff_type !== DIFF_INSERT) {\r\n            char_count1 += diff_text.length;\r\n        }\r\n        if (diff_type !== DIFF_DELETE) {\r\n            char_count2 += diff_text.length;\r\n        }\r\n    }\r\n    // Pick up the leftover patch if not empty.\r\n    if (patchDiffLength) {\r\n        this.patch_addContext_(patch, prepatch_text);\r\n        patches.push(patch);\r\n    }\r\n\r\n    return patches;\r\n};\r\n\r\n\r\n/**\r\n * Given an array of patches, return another array that is identical.\r\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\r\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\r\n */\r\ndiff_match_patch.prototype.patch_deepCopy = function (patches) {\r\n    // Making deep copies is hard in JavaScript.\r\n    var patchesCopy = [];\r\n    for (var x = 0; x < patches.length; x++) {\r\n        var patch = patches[x];\r\n        var patchCopy = new diff_match_patch.patch_obj();\r\n        patchCopy.diffs = [];\r\n        for (var y = 0; y < patch.diffs.length; y++) {\r\n            patchCopy.diffs[y] =\r\n                new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]);\r\n        }\r\n        patchCopy.start1 = patch.start1;\r\n        patchCopy.start2 = patch.start2;\r\n        patchCopy.length1 = patch.length1;\r\n        patchCopy.length2 = patch.length2;\r\n        patchesCopy[x] = patchCopy;\r\n    }\r\n    return patchesCopy;\r\n};\r\n\r\n\r\n/**\r\n * Merge a set of patches onto the text.  Return a patched text, as well\r\n * as a list of true/false values indicating which patches were applied.\r\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\r\n * @param {string} text Old text.\r\n * @return {!Array.<string|!Array.<boolean>>} Two element Array, containing the\r\n *      new text and an array of boolean values.\r\n */\r\ndiff_match_patch.prototype.patch_apply = function (patches, text) {\r\n    if (patches.length == 0) {\r\n        return [text, []];\r\n    }\r\n\r\n    // Deep copy the patches so that no changes are made to originals.\r\n    patches = this.patch_deepCopy(patches);\r\n\r\n    var nullPadding = this.patch_addPadding(patches);\r\n    text = nullPadding + text + nullPadding;\r\n\r\n    this.patch_splitMax(patches);\r\n    // delta keeps track of the offset between the expected and actual location\r\n    // of the previous patch.  If there are patches expected at positions 10 and\r\n    // 20, but the first patch was found at 12, delta is 2 and the second patch\r\n    // has an effective expected position of 22.\r\n    var delta = 0;\r\n    var results = [];\r\n    for (var x = 0; x < patches.length; x++) {\r\n        var expected_loc = patches[x].start2 + delta;\r\n        var text1 = this.diff_text1(patches[x].diffs);\r\n        var start_loc;\r\n        var end_loc = -1;\r\n        if (text1.length > this.Match_MaxBits) {\r\n            // patch_splitMax will only provide an oversized pattern in the case of\r\n            // a monster delete.\r\n            start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits),\r\n                expected_loc);\r\n            if (start_loc != -1) {\r\n                end_loc = this.match_main(text,\r\n                    text1.substring(text1.length - this.Match_MaxBits),\r\n                    expected_loc + text1.length - this.Match_MaxBits);\r\n                if (end_loc == -1 || start_loc >= end_loc) {\r\n                    // Can't find valid trailing context.  Drop this patch.\r\n                    start_loc = -1;\r\n                }\r\n            }\r\n        } else {\r\n            start_loc = this.match_main(text, text1, expected_loc);\r\n        }\r\n        if (start_loc == -1) {\r\n            // No match found.  :(\r\n            results[x] = false;\r\n            // Subtract the delta for this failed patch from subsequent patches.\r\n            delta -= patches[x].length2 - patches[x].length1;\r\n        } else {\r\n            // Found a match.  :)\r\n            results[x] = true;\r\n            delta = start_loc - expected_loc;\r\n            var text2;\r\n            if (end_loc == -1) {\r\n                text2 = text.substring(start_loc, start_loc + text1.length);\r\n            } else {\r\n                text2 = text.substring(start_loc, end_loc + this.Match_MaxBits);\r\n            }\r\n            if (text1 == text2) {\r\n                // Perfect match, just shove the replacement text in.\r\n                text = text.substring(0, start_loc) +\r\n                    this.diff_text2(patches[x].diffs) +\r\n                    text.substring(start_loc + text1.length);\r\n            } else {\r\n                // Imperfect match.  Run a diff to get a framework of equivalent\r\n                // indices.\r\n                var diffs = this.diff_main(text1, text2, false);\r\n                if (text1.length > this.Match_MaxBits &&\r\n                    this.diff_levenshtein(diffs) / text1.length >\r\n                    this.Patch_DeleteThreshold) {\r\n                    // The end points match, but the content is unacceptably bad.\r\n                    results[x] = false;\r\n                } else {\r\n                    this.diff_cleanupSemanticLossless(diffs);\r\n                    var index1 = 0;\r\n                    var index2;\r\n                    for (var y = 0; y < patches[x].diffs.length; y++) {\r\n                        var mod = patches[x].diffs[y];\r\n                        if (mod[0] !== DIFF_EQUAL) {\r\n                            index2 = this.diff_xIndex(diffs, index1);\r\n                        }\r\n                        if (mod[0] === DIFF_INSERT) {  // Insertion\r\n                            text = text.substring(0, start_loc + index2) + mod[1] +\r\n                                text.substring(start_loc + index2);\r\n                        } else if (mod[0] === DIFF_DELETE) {  // Deletion\r\n                            text = text.substring(0, start_loc + index2) +\r\n                                text.substring(start_loc + this.diff_xIndex(diffs,\r\n                                    index1 + mod[1].length));\r\n                        }\r\n                        if (mod[0] !== DIFF_DELETE) {\r\n                            index1 += mod[1].length;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    // Strip the padding off.\r\n    text = text.substring(nullPadding.length, text.length - nullPadding.length);\r\n    return [text, results];\r\n};\r\n\r\n\r\n/**\r\n * Add some padding on text start and end so that edges can match something.\r\n * Intended to be called only from within patch_apply.\r\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\r\n * @return {string} The padding string added to each side.\r\n */\r\ndiff_match_patch.prototype.patch_addPadding = function (patches) {\r\n    var paddingLength = this.Patch_Margin;\r\n    var nullPadding = '';\r\n    for (var x = 1; x <= paddingLength; x++) {\r\n        nullPadding += String.fromCharCode(x);\r\n    }\r\n\r\n    // Bump all the patches forward.\r\n    for (var x = 0; x < patches.length; x++) {\r\n        patches[x].start1 += paddingLength;\r\n        patches[x].start2 += paddingLength;\r\n    }\r\n\r\n    // Add some padding on start of first diff.\r\n    var patch = patches[0];\r\n    var diffs = patch.diffs;\r\n    if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {\r\n        // Add nullPadding equality.\r\n        diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));\r\n        patch.start1 -= paddingLength;  // Should be 0.\r\n        patch.start2 -= paddingLength;  // Should be 0.\r\n        patch.length1 += paddingLength;\r\n        patch.length2 += paddingLength;\r\n    } else if (paddingLength > diffs[0][1].length) {\r\n        // Grow first equality.\r\n        var extraLength = paddingLength - diffs[0][1].length;\r\n        diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1];\r\n        patch.start1 -= extraLength;\r\n        patch.start2 -= extraLength;\r\n        patch.length1 += extraLength;\r\n        patch.length2 += extraLength;\r\n    }\r\n\r\n    // Add some padding on end of last diff.\r\n    patch = patches[patches.length - 1];\r\n    diffs = patch.diffs;\r\n    if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) {\r\n        // Add nullPadding equality.\r\n        diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));\r\n        patch.length1 += paddingLength;\r\n        patch.length2 += paddingLength;\r\n    } else if (paddingLength > diffs[diffs.length - 1][1].length) {\r\n        // Grow last equality.\r\n        var extraLength = paddingLength - diffs[diffs.length - 1][1].length;\r\n        diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength);\r\n        patch.length1 += extraLength;\r\n        patch.length2 += extraLength;\r\n    }\r\n\r\n    return nullPadding;\r\n};\r\n\r\n\r\n/**\r\n * Look through the patches and break up any which are longer than the maximum\r\n * limit of the match algorithm.\r\n * Intended to be called only from within patch_apply.\r\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\r\n */\r\ndiff_match_patch.prototype.patch_splitMax = function (patches) {\r\n    var patch_size = this.Match_MaxBits;\r\n    for (var x = 0; x < patches.length; x++) {\r\n        if (patches[x].length1 <= patch_size) {\r\n            continue;\r\n        }\r\n        var bigpatch = patches[x];\r\n        // Remove the big old patch.\r\n        patches.splice(x--, 1);\r\n        var start1 = bigpatch.start1;\r\n        var start2 = bigpatch.start2;\r\n        var precontext = '';\r\n        while (bigpatch.diffs.length !== 0) {\r\n            // Create one of several smaller patches.\r\n            var patch = new diff_match_patch.patch_obj();\r\n            var empty = true;\r\n            patch.start1 = start1 - precontext.length;\r\n            patch.start2 = start2 - precontext.length;\r\n            if (precontext !== '') {\r\n                patch.length1 = patch.length2 = precontext.length;\r\n                patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, precontext));\r\n            }\r\n            while (bigpatch.diffs.length !== 0 &&\r\n                patch.length1 < patch_size - this.Patch_Margin) {\r\n                var diff_type = bigpatch.diffs[0][0];\r\n                var diff_text = bigpatch.diffs[0][1];\r\n                if (diff_type === DIFF_INSERT) {\r\n                    // Insertions are harmless.\r\n                    patch.length2 += diff_text.length;\r\n                    start2 += diff_text.length;\r\n                    patch.diffs.push(bigpatch.diffs.shift());\r\n                    empty = false;\r\n                } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 &&\r\n                    patch.diffs[0][0] == DIFF_EQUAL &&\r\n                    diff_text.length > 2 * patch_size) {\r\n                    // This is a large deletion.  Let it pass in one chunk.\r\n                    patch.length1 += diff_text.length;\r\n                    start1 += diff_text.length;\r\n                    empty = false;\r\n                    patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));\r\n                    bigpatch.diffs.shift();\r\n                } else {\r\n                    // Deletion or equality.  Only take as much as we can stomach.\r\n                    diff_text = diff_text.substring(0,\r\n                        patch_size - patch.length1 - this.Patch_Margin);\r\n                    patch.length1 += diff_text.length;\r\n                    start1 += diff_text.length;\r\n                    if (diff_type === DIFF_EQUAL) {\r\n                        patch.length2 += diff_text.length;\r\n                        start2 += diff_text.length;\r\n                    } else {\r\n                        empty = false;\r\n                    }\r\n                    patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));\r\n                    if (diff_text == bigpatch.diffs[0][1]) {\r\n                        bigpatch.diffs.shift();\r\n                    } else {\r\n                        bigpatch.diffs[0][1] =\r\n                            bigpatch.diffs[0][1].substring(diff_text.length);\r\n                    }\r\n                }\r\n            }\r\n            // Compute the head context for the next patch.\r\n            precontext = this.diff_text2(patch.diffs);\r\n            precontext =\r\n                precontext.substring(precontext.length - this.Patch_Margin);\r\n            // Append the end context for this patch.\r\n            var postcontext = this.diff_text1(bigpatch.diffs)\r\n                .substring(0, this.Patch_Margin);\r\n            if (postcontext !== '') {\r\n                patch.length1 += postcontext.length;\r\n                patch.length2 += postcontext.length;\r\n                if (patch.diffs.length !== 0 &&\r\n                    patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) {\r\n                    patch.diffs[patch.diffs.length - 1][1] += postcontext;\r\n                } else {\r\n                    patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, postcontext));\r\n                }\r\n            }\r\n            if (!empty) {\r\n                patches.splice(++x, 0, patch);\r\n            }\r\n        }\r\n    }\r\n};\r\n\r\n\r\n/**\r\n * Take a list of patches and return a textual representation.\r\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\r\n * @return {string} Text representation of patches.\r\n */\r\ndiff_match_patch.prototype.patch_toText = function (patches) {\r\n    var text = [];\r\n    for (var x = 0; x < patches.length; x++) {\r\n        text[x] = patches[x];\r\n    }\r\n    return text.join('');\r\n};\r\n\r\n\r\n/**\r\n * Parse a textual representation of patches and return a list of Patch objects.\r\n * @param {string} textline Text representation of patches.\r\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\r\n * @throws {!Error} If invalid input.\r\n */\r\ndiff_match_patch.prototype.patch_fromText = function (textline) {\r\n    var patches = [];\r\n    if (!textline) {\r\n        return patches;\r\n    }\r\n    var text = textline.split('\\n');\r\n    var textPointer = 0;\r\n    var patchHeader = /^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$/;\r\n    while (textPointer < text.length) {\r\n        var m = text[textPointer].match(patchHeader);\r\n        if (!m) {\r\n            throw new Error('Invalid patch string: ' + text[textPointer]);\r\n        }\r\n        var patch = new diff_match_patch.patch_obj();\r\n        patches.push(patch);\r\n        patch.start1 = parseInt(m[1], 10);\r\n        if (m[2] === '') {\r\n            patch.start1--;\r\n            patch.length1 = 1;\r\n        } else if (m[2] == '0') {\r\n            patch.length1 = 0;\r\n        } else {\r\n            patch.start1--;\r\n            patch.length1 = parseInt(m[2], 10);\r\n        }\r\n\r\n        patch.start2 = parseInt(m[3], 10);\r\n        if (m[4] === '') {\r\n            patch.start2--;\r\n            patch.length2 = 1;\r\n        } else if (m[4] == '0') {\r\n            patch.length2 = 0;\r\n        } else {\r\n            patch.start2--;\r\n            patch.length2 = parseInt(m[4], 10);\r\n        }\r\n        textPointer++;\r\n\r\n        while (textPointer < text.length) {\r\n            var sign = text[textPointer].charAt(0);\r\n            try {\r\n                var line = decodeURI(text[textPointer].substring(1));\r\n            } catch (ex) {\r\n                // Malformed URI sequence.\r\n                throw new Error('Illegal escape in patch_fromText: ' + line);\r\n            }\r\n            if (sign == '-') {\r\n                // Deletion.\r\n                patch.diffs.push(new diff_match_patch.Diff(DIFF_DELETE, line));\r\n            } else if (sign == '+') {\r\n                // Insertion.\r\n                patch.diffs.push(new diff_match_patch.Diff(DIFF_INSERT, line));\r\n            } else if (sign == ' ') {\r\n                // Minor equality.\r\n                patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, line));\r\n            } else if (sign == '@') {\r\n                // Start of next patch.\r\n                break;\r\n            } else if (sign === '') {\r\n                // Blank line?  Whatever.\r\n            } else {\r\n                // WTF?\r\n                throw new Error('Invalid patch mode \"' + sign + '\" in: ' + line);\r\n            }\r\n            textPointer++;\r\n        }\r\n    }\r\n    return patches;\r\n};\r\n\r\n\r\n/**\r\n * Class representing one patch operation.\r\n * @constructor\r\n */\r\ndiff_match_patch.patch_obj = function () {\r\n    /** @type {!Array.<!diff_match_patch.Diff>} */\r\n    this.diffs = [];\r\n    /** @type {?number} */\r\n    this.start1 = null;\r\n    /** @type {?number} */\r\n    this.start2 = null;\r\n    /** @type {number} */\r\n    this.length1 = 0;\r\n    /** @type {number} */\r\n    this.length2 = 0;\r\n};\r\n\r\n\r\n/**\r\n * Emulate GNU diff's format.\r\n * Header: @@ -382,8 +481,9 @@\r\n * Indices are printed as 1-based, not 0-based.\r\n * @return {string} The GNU diff string.\r\n */\r\ndiff_match_patch.patch_obj.prototype.toString = function () {\r\n    var coords1, coords2;\r\n    if (this.length1 === 0) {\r\n        coords1 = this.start1 + ',0';\r\n    } else if (this.length1 == 1) {\r\n        coords1 = this.start1 + 1;\r\n    } else {\r\n        coords1 = (this.start1 + 1) + ',' + this.length1;\r\n    }\r\n    if (this.length2 === 0) {\r\n        coords2 = this.start2 + ',0';\r\n    } else if (this.length2 == 1) {\r\n        coords2 = this.start2 + 1;\r\n    } else {\r\n        coords2 = (this.start2 + 1) + ',' + this.length2;\r\n    }\r\n    var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\\n'];\r\n    var op;\r\n    // Escape the body of the patch with %xx notation.\r\n    for (var x = 0; x < this.diffs.length; x++) {\r\n        switch (this.diffs[x][0]) {\r\n            case DIFF_INSERT:\r\n                op = '+';\r\n                break;\r\n            case DIFF_DELETE:\r\n                op = '-';\r\n                break;\r\n            case DIFF_EQUAL:\r\n                op = ' ';\r\n                break;\r\n        }\r\n        text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\\n';\r\n    }\r\n    return text.join('').replace(/%20/g, ' ');\r\n};\r\n\r\n// CLOSURE:begin_strip\r\n// Lines below here will not be included in the Closure-compatible library.\r\n\r\n// Export these global variables so that they survive Google's JS compiler.\r\n// In a browser, 'this' will be 'window'.\r\n// Users of node.js should 'require' the uncompressed version since Google's\r\n// JS compiler may break the following exports for non-browser environments.\r\n/** @suppress {globalThis} */\r\nthis['diff_match_patch'] = diff_match_patch;\r\n/** @suppress {globalThis} */\r\nthis['DIFF_DELETE'] = DIFF_DELETE;\r\n/** @suppress {globalThis} */\r\nthis['DIFF_INSERT'] = DIFF_INSERT;\r\n/** @suppress {globalThis} */\r\nthis['DIFF_EQUAL'] = DIFF_EQUAL;"]}