UNPKG

ng-diff-match-patch

Version:

A Diff-Match-Patch component for your Angular 2 + applications

2,358 lines • 283 kB
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
 */
/** @enum {number} */
const DiffOp = {
    Delete: -1,
    Equal: 0,
    Insert: 1,
};
export { DiffOp };
/** @typedef {?} */
var Diff;
export { Diff };
/**
 * Class containing the diff, match and patch methods.
 */
class DiffMatchPatch {
    constructor() {
        // Defaults.
        // Redefine these in your program to override the defaults.
        // Number of seconds to map a diff before giving up (0 for infinity).
        this.Diff_Timeout = 1.0;
        // Cost of an empty edit operation in terms of edit characters.
        this.Diff_EditCost = 4;
        // At what point is no match declared (0.0 = perfection, 1.0 = very loose).
        this.Match_Threshold = 0.5;
        // How far to search for a match (0 = exact location, 1000+ = broad match).
        // A match this many characters away from the expected location will add
        // 1.0 to the score (0.0 is a perfect match).
        this.Match_Distance = 1000;
        // When deleting a large block of text (over ~64 characters), how close do
        // the contents have to be to match the expected contents. (0.0 = perfection,
        // 1.0 = very loose).  Note that Match_Threshold controls how closely the
        // end points of a delete need to match.
        this.Patch_DeleteThreshold = 0.5;
        // Chunk size for context length.
        this.Patch_Margin = 4;
        // The number of bits in an int.
        this.Match_MaxBits = 32;
        /**
         * The data structure representing a diff is an array of tuples:
         * [[DiffOp.Delete, 'Hello'], [DiffOp.Insert, 'Goodbye'], [DiffOp.Equal, ' world.']]
         * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
         */
        this.whitespaceRegex_ = new RegExp('/\s/');
        this.linebreakRegex_ = new RegExp('/[\r\n]/');
        this.blanklineEndRegex_ = new RegExp('/\n\r?\n$/');
        this.blanklineStartRegex_ = new RegExp('/^\r?\n\r?\n/');
        /**
         * Convert a diff array into a pretty HTML report.
         * @param diffs Array of diff tuples.
         * @return HTML representation.
         */
        this.diff_prettyHtml = function (diffs) {
            /** @type {?} */
            const html = [];
            /** @type {?} */
            const pattern_amp = /&/g;
            /** @type {?} */
            const pattern_lt = /</g;
            /** @type {?} */
            const pattern_gt = />/g;
            /** @type {?} */
            const pattern_para = /\n/g;
            for (let x = 0; x < diffs.length; x++) {
                /** @type {?} */
                const op = diffs[x][0];
                /** @type {?} */
                const data = diffs[x][1];
                /** @type {?} */
                const text = data.replace(pattern_amp, '&amp;').replace(pattern_lt, '&lt;')
                    .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');
                switch (op) {
                    case 1 /* Insert */:
                        html[x] = '<ins style="background:#e6ffe6;">' + text + '</ins>';
                        break;
                    case -1 /* Delete */:
                        html[x] = '<del style="background:#ffe6e6;">' + text + '</del>';
                        break;
                    case 0 /* Equal */:
                        html[x] = '<span>' + text + '</span>';
                        break;
                }
            }
            return html.join('');
        };
        /**
         * Look through the patches and break up any which are longer than the maximum
         * limit of the match algorithm.
         * Intended to be called only from within patch_apply.
         * @param patches Array of Patch objects.
         */
        this.patch_splitMax = function (patches) {
            /** @type {?} */
            const patch_size = this.Match_MaxBits;
            for (let x = 0; x < patches.length; x++) {
                if (patches[x].length1 <= patch_size) {
                    continue;
                }
                /** @type {?} */
                const bigpatch = patches[x];
                // Remove the big old patch.
                patches.splice(x--, 1);
                /** @type {?} */
                let start1 = bigpatch.start1;
                /** @type {?} */
                let start2 = bigpatch.start2;
                /** @type {?} */
                let precontext = '';
                while (bigpatch.diffs.length !== 0) {
                    /** @type {?} */
                    const patch = new patch_obj();
                    /** @type {?} */
                    let empty = true;
                    patch.start1 = start1 - precontext.length;
                    patch.start2 = start2 - precontext.length;
                    if (precontext !== '') {
                        patch.length1 = patch.length2 = precontext.length;
                        patch.diffs.push([0 /* Equal */, precontext]);
                    }
                    while (bigpatch.diffs.length !== 0 &&
                        patch.length1 < patch_size - this.Patch_Margin) {
                        /** @type {?} */
                        const diff_type = bigpatch.diffs[0][0];
                        /** @type {?} */
                        let diff_text = bigpatch.diffs[0][1];
                        if (diff_type === 1 /* Insert */) {
                            // Insertions are harmless.
                            patch.length2 += diff_text.length;
                            start2 += diff_text.length;
                            patch.diffs.push(bigpatch.diffs.shift());
                            empty = false;
                        }
                        else if (diff_type === -1 /* Delete */ && patch.diffs.length == 1 &&
                            patch.diffs[0][0] == 0 /* Equal */ &&
                            diff_text.length > 2 * patch_size) {
                            // This is a large deletion.  Let it pass in one chunk.
                            patch.length1 += diff_text.length;
                            start1 += diff_text.length;
                            empty = false;
                            patch.diffs.push([diff_type, diff_text]);
                            bigpatch.diffs.shift();
                        }
                        else {
                            // Deletion or equality.  Only take as much as we can stomach.
                            diff_text = diff_text.substring(0, patch_size - patch.length1 - this.Patch_Margin);
                            patch.length1 += diff_text.length;
                            start1 += diff_text.length;
                            if (diff_type === 0 /* Equal */) {
                                patch.length2 += diff_text.length;
                                start2 += diff_text.length;
                            }
                            else {
                                empty = false;
                            }
                            patch.diffs.push([diff_type, diff_text]);
                            if (diff_text == bigpatch.diffs[0][1]) {
                                bigpatch.diffs.shift();
                            }
                            else {
                                bigpatch.diffs[0][1] =
                                    bigpatch.diffs[0][1].substring(diff_text.length);
                            }
                        }
                    }
                    // Compute the head context for the next patch.
                    precontext = this.diff_text2(patch.diffs);
                    precontext =
                        precontext.substring(precontext.length - this.Patch_Margin);
                    /** @type {?} */
                    const postcontext = this.diff_text1(bigpatch.diffs)
                        .substring(0, this.Patch_Margin);
                    if (postcontext !== '') {
                        patch.length1 += postcontext.length;
                        patch.length2 += postcontext.length;
                        if (patch.diffs.length !== 0 &&
                            patch.diffs[patch.diffs.length - 1][0] === 0 /* Equal */) {
                            patch.diffs[patch.diffs.length - 1][1] += postcontext;
                        }
                        else {
                            patch.diffs.push([0 /* Equal */, postcontext]);
                        }
                    }
                    if (!empty) {
                        patches.splice(++x, 0, patch);
                    }
                }
            }
        };
    }
    /**
     * Find the differences between two texts.  Simplifies the problem by stripping
     * any common prefix or suffix off the texts before diffing.
     * @param {?} text1 Old string to be diffed.
     * @param {?} text2 New string to be diffed.
     * @param {?=} opt_checklines Optional speedup flag. If present and false,
     *     then don't run a line-level diff first to identify the changed areas.
     *     Defaults to true, which does a faster, slightly less optimal diff.
     * @param {?=} opt_deadline Optional time when the diff should be complete
     *     by.  Used internally for recursive calls.  Users should set DiffTimeout
     *     instead.
     * @return {?} Array of diff tuples.
     */
    diff_main(text1, text2, opt_checklines, opt_deadline) {
        // Set a deadline by which time the diff must be complete.
        if (typeof opt_deadline == 'undefined') {
            if (this.Diff_Timeout <= 0) {
                opt_deadline = Number.MAX_VALUE;
            }
            else {
                opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000;
            }
        }
        /** @type {?} */
        const deadline = opt_deadline;
        // Check for null inputs.
        if (text1 == null || text2 == null) {
            throw new Error('Null input. (diff_main)');
        }
        // Check for equality (speedup).
        if (text1 == text2) {
            if (text1) {
                return [[0 /* Equal */, text1]];
            }
            return [];
        }
        if (typeof opt_checklines == 'undefined') {
            opt_checklines = true;
        }
        /** @type {?} */
        const checklines = opt_checklines;
        /** @type {?} */
        let commonlength = this.diff_commonPrefix(text1, text2);
        /** @type {?} */
        const commonprefix = text1.substring(0, commonlength);
        text1 = text1.substring(commonlength);
        text2 = text2.substring(commonlength);
        // Trim off common suffix (speedup).
        commonlength = this.diff_commonSuffix(text1, text2);
        /** @type {?} */
        const commonsuffix = text1.substring(text1.length - commonlength);
        text1 = text1.substring(0, text1.length - commonlength);
        text2 = text2.substring(0, text2.length - commonlength);
        /** @type {?} */
        const diffs = this.diff_compute_(text1, text2, checklines, deadline);
        // Restore the prefix and suffix.
        if (commonprefix) {
            diffs.unshift([0 /* Equal */, commonprefix]);
        }
        if (commonsuffix) {
            diffs.push([0 /* Equal */, commonsuffix]);
        }
        this.diff_cleanupMerge(diffs);
        return diffs;
    }
    ;
    /**
     * Find the differences between two texts.  Assumes that the texts do not
     * have any common prefix or suffix.
     * @param {?} text1 Old string to be diffed.
     * @param {?} text2 New string to be diffed.
     * @param {?} checklines Speedup flag.  If false, then don't run a
     *     line-level diff first to identify the changed areas.
     *     If true, then run a faster, slightly less optimal diff.
     * @param {?} deadline Time when the diff should be complete by.
     * @return {?} Array of diff tuples.
     */
    diff_compute_(text1, text2, checklines, deadline) {
        /** @type {?} */
        let diffs;
        if (!text1) {
            // Just add some text (speedup).
            return [[1 /* Insert */, text2]];
        }
        if (!text2) {
            // Just delete some text (speedup).
            return [[-1 /* Delete */, text1]];
        }
        /** @type {?} */
        const longtext = text1.length > text2.length ? text1 : text2;
        /** @type {?} */
        const shorttext = text1.length > text2.length ? text2 : text1;
        /** @type {?} */
        const i = longtext.indexOf(shorttext);
        if (i != -1) {
            // Shorter text is inside the longer text (speedup).
            diffs = [[1 /* Insert */, longtext.substring(0, i)],
                [0 /* Equal */, shorttext],
                [1 /* Insert */, longtext.substring(i + shorttext.length)]];
            // Swap insertions for deletions if diff is reversed.
            if (text1.length > text2.length) {
                diffs[0][0] = diffs[2][0] = -1 /* Delete */;
            }
            return diffs;
        }
        if (shorttext.length == 1) {
            // Single character string.
            // After the previous speedup, the character can't be an equality.
            return [[-1 /* Delete */, text1], [1 /* Insert */, text2]];
        }
        /** @type {?} */
        const hm = this.diff_halfMatch_(text1, text2);
        if (hm) {
            /** @type {?} */
            const text1_a = hm[0];
            /** @type {?} */
            const text1_b = hm[1];
            /** @type {?} */
            const text2_a = hm[2];
            /** @type {?} */
            const text2_b = hm[3];
            /** @type {?} */
            const mid_common = hm[4];
            /** @type {?} */
            const diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);
            /** @type {?} */
            const diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);
            // Merge the results.
            return diffs_a.concat([[0 /* Equal */, mid_common]], diffs_b);
        }
        if (checklines && text1.length > 100 && text2.length > 100) {
            return this.diff_lineMode_(text1, text2, deadline);
        }
        return this.diff_bisect_(text1, text2, deadline);
    }
    ;
    /**
     * Do a quick line-level diff on both strings, then rediff the parts for
     * greater accuracy.
     * This speedup can produce non-minimal diffs.
     * @param {?} text1 Old string to be diffed.
     * @param {?} text2 New string to be diffed.
     * @param {?} deadline Time when the diff should be complete by.
     * @return {?} Array of diff tuples.
     */
    diff_lineMode_(text1, text2, deadline) {
        /** @type {?} */
        const a = this.diff_linesToChars_(text1, text2);
        text1 = a.chars1;
        text2 = a.chars2;
        /** @type {?} */
        const linearray = a.lineArray;
        /** @type {?} */
        const diffs = this.diff_main(text1, text2, false, deadline);
        // Convert the diff back to original text.
        this.diff_charsToLines_(diffs, linearray);
        // Eliminate freak matches (e.g. blank lines)
        this.diff_cleanupSemantic(diffs);
        // Rediff any replacement blocks, this time character-by-character.
        // Add a dummy entry at the end.
        diffs.push([0 /* Equal */, '']);
        /** @type {?} */
        let pointer = 0;
        /** @type {?} */
        let count_delete = 0;
        /** @type {?} */
        let count_insert = 0;
        /** @type {?} */
        let text_delete = '';
        /** @type {?} */
        let text_insert = '';
        while (pointer < diffs.length) {
            switch (diffs[pointer][0]) {
                case 1 /* Insert */:
                    count_insert++;
                    text_insert += diffs[pointer][1];
                    break;
                case -1 /* Delete */:
                    count_delete++;
                    text_delete += diffs[pointer][1];
                    break;
                case 0 /* Equal */:
                    // Upon reaching an equality, check for prior redundancies.
                    if (count_delete >= 1 && count_insert >= 1) {
                        // Delete the offending records and add the merged ones.
                        diffs.splice(pointer - count_delete - count_insert, count_delete + count_insert);
                        pointer = pointer - count_delete - count_insert;
                        /** @type {?} */
                        const b = this.diff_main(text_delete, text_insert, false, deadline);
                        for (let j = b.length - 1; j >= 0; j--) {
                            diffs.splice(pointer, 0, b[j]);
                        }
                        pointer = pointer + b.length;
                    }
                    count_insert = 0;
                    count_delete = 0;
                    text_delete = '';
                    text_insert = '';
                    break;
            }
            pointer++;
        }
        diffs.pop(); // Remove the dummy entry at the end.
        return diffs;
    }
    ;
    /**
     * Find the 'middle snake' of a diff, split the problem in two
     * and return the recursively constructed diff.
     * See Myers 1986 paper: An O(ND) Difference Algorithm and Its constiations.
     * @param {?} text1 Old string to be diffed.
     * @param {?} text2 New string to be diffed.
     * @param {?} deadline Time at which to bail if not yet complete.
     * @return {?} Array of diff tuples.
     */
    diff_bisect_(text1, text2, deadline) {
        /** @type {?} */
        const text1_length = text1.length;
        /** @type {?} */
        const text2_length = text2.length;
        /** @type {?} */
        const max_d = Math.ceil((text1_length + text2_length) / 2);
        /** @type {?} */
        const v_offset = max_d;
        /** @type {?} */
        const v_length = 2 * max_d;
        /** @type {?} */
        const v1 = new Array(v_length);
        /** @type {?} */
        const v2 = new Array(v_length);
        // Setting all elements to -1 is faster in Chrome & Firefox than mixing
        // integers and undefined.
        for (let x = 0; x < v_length; x++) {
            v1[x] = -1;
            v2[x] = -1;
        }
        v1[v_offset + 1] = 0;
        v2[v_offset + 1] = 0;
        /** @type {?} */
        const delta = text1_length - text2_length;
        /** @type {?} */
        const front = (delta % 2 != 0);
        /** @type {?} */
        let k1start = 0;
        /** @type {?} */
        let k1end = 0;
        /** @type {?} */
        let k2start = 0;
        /** @type {?} */
        let k2end = 0;
        for (let d = 0; d < max_d; d++) {
            // Bail out if deadline is reached.
            if ((new Date()).getTime() > deadline) {
                break;
            }
            // Walk the front path one step.
            for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
                /** @type {?} */
                const k1_offset = v_offset + k1;
                /** @type {?} */
                let x1;
                if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {
                    x1 = v1[k1_offset + 1];
                }
                else {
                    x1 = v1[k1_offset - 1] + 1;
                }
                /** @type {?} */
                let y1 = x1 - k1;
                while (x1 < text1_length && y1 < text2_length &&
                    text1.charAt(x1) == text2.charAt(y1)) {
                    x1++;
                    y1++;
                }
                v1[k1_offset] = x1;
                if (x1 > text1_length) {
                    // Ran off the right of the graph.
                    k1end += 2;
                }
                else if (y1 > text2_length) {
                    // Ran off the bottom of the graph.
                    k1start += 2;
                }
                else if (front) {
                    /** @type {?} */
                    const k2_offset = v_offset + delta - k1;
                    if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {
                        /** @type {?} */
                        const x2 = text1_length - v2[k2_offset];
                        if (x1 >= x2) {
                            // Overlap detected.
                            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
                        }
                    }
                }
            }
            // Walk the reverse path one step.
            for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
                /** @type {?} */
                const k2_offset = v_offset + k2;
                /** @type {?} */
                let x2;
                if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {
                    x2 = v2[k2_offset + 1];
                }
                else {
                    x2 = v2[k2_offset - 1] + 1;
                }
                /** @type {?} */
                let y2 = x2 - k2;
                while (x2 < text1_length && y2 < text2_length &&
                    text1.charAt(text1_length - x2 - 1) ==
                        text2.charAt(text2_length - y2 - 1)) {
                    x2++;
                    y2++;
                }
                v2[k2_offset] = x2;
                if (x2 > text1_length) {
                    // Ran off the left of the graph.
                    k2end += 2;
                }
                else if (y2 > text2_length) {
                    // Ran off the top of the graph.
                    k2start += 2;
                }
                else if (!front) {
                    /** @type {?} */
                    const k1_offset = v_offset + delta - k2;
                    if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {
                        /** @type {?} */
                        const x1 = v1[k1_offset];
                        /** @type {?} */
                        const y1 = v_offset + x1 - k1_offset;
                        // Mirror x2 onto top-left coordinate system.
                        x2 = text1_length - x2;
                        if (x1 >= x2) {
                            // Overlap detected.
                            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
                        }
                    }
                }
            }
        }
        // Diff took too long and hit the deadline or
        // number of diffs equals number of characters, no commonality at all.
        return [[-1 /* Delete */, text1], [1 /* Insert */, text2]];
    }
    ;
    /**
     * Given the location of the 'middle snake', split the diff in two parts
     * and recurse.
     * @param {?} text1 Old string to be diffed.
     * @param {?} text2 New string to be diffed.
     * @param {?} x Index of split point in text1.
     * @param {?} y Index of split point in text2.
     * @param {?} deadline Time at which to bail if not yet complete.
     * @return {?} Array of diff tuples.
     */
    diff_bisectSplit_(text1, text2, x, y, deadline) {
        /** @type {?} */
        const text1a = text1.substring(0, x);
        /** @type {?} */
        const text2a = text2.substring(0, y);
        /** @type {?} */
        const text1b = text1.substring(x);
        /** @type {?} */
        const text2b = text2.substring(y);
        /** @type {?} */
        const diffs = this.diff_main(text1a, text2a, false, deadline);
        /** @type {?} */
        const diffsb = this.diff_main(text1b, text2b, false, deadline);
        return diffs.concat(diffsb);
    }
    ;
    /**
     * Split two texts into an array of strings.  Reduce the texts to a string of
     * hashes where each Unicode character represents one line.
     * @param {?} text1 First string.
     * @param {?} text2 Second string.
     * @return {?} }
     *     An object containing the encoded text1, the encoded text2 and
     *     the array of unique strings.
     *     The zeroth element of the array of unique strings is intentionally blank.
     */
    diff_linesToChars_(text1, text2) {
        /** @type {?} */
        const lineArray = [];
        /** @type {?} */
        const lineHash = {}; // e.g. lineHash['Hello\n'] == 4
        // '\x00' is a valid character, but constious debuggers don't like it.
        // So we'll insert a junk entry to avoid generating a null character.
        lineArray[0] = '';
        /** @type {?} */
        const chars1 = this.diff_linesToCharsMunge_(text1, lineArray, lineHash);
        /** @type {?} */
        const chars2 = this.diff_linesToCharsMunge_(text2, lineArray, lineHash);
        return { chars1: chars1, chars2: chars2, lineArray: lineArray };
    }
    ;
    /**
     * Split a text into an array of strings.  Reduce the texts to a string of
     * hashes where each Unicode character represents one line.
     * Modifies linearray and linehash through being a closure.
     * @param {?} text String to encode.
     * @param {?} lineArray
     * @param {?} lineHash
     * @return {?} Encoded string.
     */
    diff_linesToCharsMunge_(text, lineArray, lineHash) {
        /** @type {?} */
        let chars = '';
        /** @type {?} */
        let lineStart = 0;
        /** @type {?} */
        let lineEnd = -1;
        /** @type {?} */
        let lineArrayLength = lineArray.length;
        while (lineEnd < text.length - 1) {
            lineEnd = text.indexOf('\n', lineStart);
            if (lineEnd == -1) {
                lineEnd = text.length - 1;
            }
            /** @type {?} */
            const line = text.substring(lineStart, lineEnd + 1);
            lineStart = lineEnd + 1;
            if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :
                (lineHash[line] !== undefined)) {
                chars += String.fromCharCode(lineHash[line]);
            }
            else {
                chars += String.fromCharCode(lineArrayLength);
                lineHash[line] = lineArrayLength;
                lineArray[lineArrayLength++] = line;
            }
        }
        return chars;
    }
    /**
     * Rehydrate the text in a diff from a string of line hashes to real lines of
     * text.
     * @param {?} diffs Array of diff tuples.
     * @param {?} lineArray Array of unique strings.
     * @return {?}
     */
    diff_charsToLines_(diffs, lineArray) {
        for (let x = 0; x < diffs.length; x++) {
            /** @type {?} */
            const chars = diffs[x][1];
            /** @type {?} */
            const text = [];
            for (let y = 0; y < chars.length; y++) {
                text[y] = lineArray[chars.charCodeAt(y)];
            }
            diffs[x][1] = text.join('');
        }
    }
    ;
    /**
     * Determine the common prefix of two strings.
     * @param {?} text1 First string.
     * @param {?} text2 Second string.
     * @return {?} The number of characters common to the start of each
     *     string.
     */
    diff_commonPrefix(text1, text2) {
        // Quick check for common null cases.
        if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
            return 0;
        }
        /** @type {?} */
        let pointermin = 0;
        /** @type {?} */
        let pointermax = Math.min(text1.length, text2.length);
        /** @type {?} */
        let pointermid = pointermax;
        /** @type {?} */
        let pointerstart = 0;
        while (pointermin < pointermid) {
            if (text1.substring(pointerstart, pointermid) ==
                text2.substring(pointerstart, pointermid)) {
                pointermin = pointermid;
                pointerstart = pointermin;
            }
            else {
                pointermax = pointermid;
            }
            pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
        }
        return pointermid;
    }
    ;
    /**
     * Determine the common suffix of two strings.
     * @param {?} text1 First string.
     * @param {?} text2 Second string.
     * @return {?} The number of characters common to the end of each string.
     */
    diff_commonSuffix(text1, text2) {
        // Quick check for common null cases.
        if (!text1 || !text2 ||
            text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {
            return 0;
        }
        /** @type {?} */
        let pointermin = 0;
        /** @type {?} */
        let pointermax = Math.min(text1.length, text2.length);
        /** @type {?} */
        let pointermid = pointermax;
        /** @type {?} */
        let pointerend = 0;
        while (pointermin < pointermid) {
            if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==
                text2.substring(text2.length - pointermid, text2.length - pointerend)) {
                pointermin = pointermid;
                pointerend = pointermin;
            }
            else {
                pointermax = pointermid;
            }
            pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
        }
        return pointermid;
    }
    ;
    /**
     * Determine if the suffix of one string is the prefix of another.
     * @param {?} text1 First string.
     * @param {?} text2 Second string.
     * @return {?} The number of characters common to the end of the first
     *     string and the start of the second string.
     */
    diff_commonOverlap_(text1, text2) {
        /** @type {?} */
        const text1_length = text1.length;
        /** @type {?} */
        const text2_length = text2.length;
        // Eliminate the null case.
        if (text1_length == 0 || text2_length == 0) {
            return 0;
        }
        // Truncate the longer string.
        if (text1_length > text2_length) {
            text1 = text1.substring(text1_length - text2_length);
        }
        else if (text1_length < text2_length) {
            text2 = text2.substring(0, text1_length);
        }
        /** @type {?} */
        const text_length = Math.min(text1_length, text2_length);
        // Quick check for the worst case.
        if (text1 == text2) {
            return text_length;
        }
        /** @type {?} */
        let best = 0;
        /** @type {?} */
        let length = 1;
        while (true) {
            /** @type {?} */
            const pattern = text1.substring(text_length - length);
            /** @type {?} */
            const found = text2.indexOf(pattern);
            if (found == -1) {
                return best;
            }
            length += found;
            if (found == 0 || text1.substring(text_length - length) ==
                text2.substring(0, length)) {
                best = length;
                length++;
            }
        }
    }
    ;
    /**
     * Do the two texts share a substring which is at least half the length of the
     * longer text?
     * This speedup can produce non-minimal diffs.
     * @param {?} text1 First string.
     * @param {?} text2 Second string.
     * @return {?} Five element Array, containing the prefix of
     *     text1, the suffix of text1, the prefix of text2, the suffix of
     *     text2 and the common middle.  Or null if there was no match.
     */
    diff_halfMatch_(text1, text2) {
        if (this.Diff_Timeout <= 0) {
            // Don't risk returning a non-optimal diff if we have unlimited time.
            return null;
        }
        /** @type {?} */
        const longtext = text1.length > text2.length ? text1 : text2;
        /** @type {?} */
        const shorttext = text1.length > text2.length ? text2 : text1;
        if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {
            return null; // Pointless.
        }
        /** @type {?} */
        const dmp = this;
        /** @type {?} */
        const hm1 = this.diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 4), dmp);
        /** @type {?} */
        const hm2 = this.diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 2), dmp);
        /** @type {?} */
        let hm;
        if (!hm1 && !hm2) {
            return null;
        }
        else if (!hm2) {
            hm = hm1;
        }
        else if (!hm1) {
            hm = hm2;
        }
        else {
            // Both matched.  Select the longest.
            hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
        }
        /** @type {?} */
        let text1_a;
        /** @type {?} */
        let text1_b;
        /** @type {?} */
        let text2_a;
        /** @type {?} */
        let text2_b;
        if (text1.length > text2.length) {
            text1_a = hm[0];
            text1_b = hm[1];
            text2_a = hm[2];
            text2_b = hm[3];
        }
        else {
            text2_a = hm[0];
            text2_b = hm[1];
            text1_a = hm[2];
            text1_b = hm[3];
        }
        /** @type {?} */
        const mid_common = hm[4];
        return [text1_a, text1_b, text2_a, text2_b, mid_common];
    }
    ;
    /**
     * Does a substring of shorttext exist within longtext such that the substring
     * is at least half the length of longtext?
     * Closure, but does not reference any external constiables.
     * @param {?} longtext Longer string.
     * @param {?} shorttext Shorter string.
     * @param {?} i Start index of quarter length substring within longtext.
     * @param {?} dmp
     * @return {?} Five element Array, containing the prefix of
     *     longtext, the suffix of longtext, the prefix of shorttext, the suffix
     *     of shorttext and the common middle.  Or null if there was no match.
     */
    diff_halfMatchI_(longtext, shorttext, i, dmp) {
        /** @type {?} */
        const seed = longtext.substring(i, i + Math.floor(longtext.length / 4));
        /** @type {?} */
        let j = -1;
        /** @type {?} */
        let best_common = '';
        /** @type {?} */
        let best_longtext_a;
        /** @type {?} */
        let best_longtext_b;
        /** @type {?} */
        let best_shorttext_a;
        /** @type {?} */
        let best_shorttext_b;
        while ((j = shorttext.indexOf(seed, j + 1)) != -1) {
            /** @type {?} */
            const prefixLength = dmp.diff_commonPrefix(longtext.substring(i), shorttext.substring(j));
            /** @type {?} */
            const suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i), shorttext.substring(0, j));
            if (best_common.length < suffixLength + prefixLength) {
                best_common = shorttext.substring(j - suffixLength, j) +
                    shorttext.substring(j, j + prefixLength);
                best_longtext_a = longtext.substring(0, i - suffixLength);
                best_longtext_b = longtext.substring(i + prefixLength);
                best_shorttext_a = shorttext.substring(0, j - suffixLength);
                best_shorttext_b = shorttext.substring(j + prefixLength);
            }
        }
        if (best_common.length * 2 >= longtext.length) {
            return [best_longtext_a, best_longtext_b,
                best_shorttext_a, best_shorttext_b, best_common];
        }
        else {
            return null;
        }
    }
    /**
     * Reduce the number of edits by eliminating semantically trivial equalities.
     * @param {?} diffs Array of diff tuples.
     * @return {?}
     */
    diff_cleanupSemantic(diffs) {
        /** @type {?} */
        let changes = false;
        /** @type {?} */
        const equalities = [];
        /** @type {?} */
        let equalitiesLength = 0;
        /** @type {?} */
        let lastequality = null;
        /** @type {?} */
        let pointer = 0;
        /** @type {?} */
        let length_insertions1 = 0;
        /** @type {?} */
        let length_deletions1 = 0;
        /** @type {?} */
        let length_insertions2 = 0;
        /** @type {?} */
        let length_deletions2 = 0;
        while (pointer < diffs.length) {
            if (diffs[pointer][0] == 0 /* Equal */) {
                // Equality found.
                equalities[equalitiesLength++] = pointer;
                length_insertions1 = length_insertions2;
                length_deletions1 = length_deletions2;
                length_insertions2 = 0;
                length_deletions2 = 0;
                lastequality = diffs[pointer][1];
            }
            else {
                // An insertion or deletion.
                if (diffs[pointer][0] == 1 /* Insert */) {
                    length_insertions2 += diffs[pointer][1].length;
                }
                else {
                    length_deletions2 += diffs[pointer][1].length;
                }
                // Eliminate an equality that is smaller or equal to the edits on both
                // sides of it.
                if (lastequality && (lastequality.length <=
                    Math.max(length_insertions1, length_deletions1)) &&
                    (lastequality.length <= Math.max(length_insertions2, length_deletions2))) {
                    // Duplicate record.
                    diffs.splice(equalities[equalitiesLength - 1], 0, [-1 /* Delete */, lastequality]);
                    // Change second copy to insert.
                    diffs[equalities[equalitiesLength - 1] + 1][0] = 1 /* Insert */;
                    // Throw away the equality we just deleted.
                    equalitiesLength--;
                    // Throw away the previous equality (it needs to be reevaluated).
                    equalitiesLength--;
                    pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
                    length_insertions1 = 0; // Reset the counters.
                    length_deletions1 = 0;
                    length_insertions2 = 0;
                    length_deletions2 = 0;
                    lastequality = null;
                    changes = true;
                }
            }
            pointer++;
        }
        // Normalize the diff.
        if (changes) {
            this.diff_cleanupMerge(diffs);
        }
        this.diff_cleanupSemanticLossless(diffs);
        // Find any overlaps between deletions and insertions.
        // e.g: <del>abcxxx</del><ins>xxxdef</ins>
        //   -> <del>abc</del>xxx<ins>def</ins>
        // e.g: <del>xxxabc</del><ins>defxxx</ins>
        //   -> <ins>def</ins>xxx<del>abc</del>
        // Only extract an overlap if it is as big as the edit ahead or behind it.
        pointer = 1;
        while (pointer < diffs.length) {
            if (diffs[pointer - 1][0] == -1 /* Delete */ &&
                diffs[pointer][0] == 1 /* Insert */) {
                /** @type {?} */
                const deletion = diffs[pointer - 1][1];
                /** @type {?} */
                const insertion = diffs[pointer][1];
                /** @type {?} */
                const overlap_length1 = this.diff_commonOverlap_(deletion, insertion);
                /** @type {?} */
                const overlap_length2 = this.diff_commonOverlap_(insertion, deletion);
                if (overlap_length1 >= overlap_length2) {
                    if (overlap_length1 >= deletion.length / 2 ||
                        overlap_length1 >= insertion.length / 2) {
                        // Overlap found.  Insert an equality and trim the surrounding edits.
                        diffs.splice(pointer, 0, [0 /* Equal */, insertion.substring(0, overlap_length1)]);
                        diffs[pointer - 1][1] =
                            deletion.substring(0, deletion.length - overlap_length1);
                        diffs[pointer + 1][1] = insertion.substring(overlap_length1);
                        pointer++;
                    }
                }
                else {
                    if (overlap_length2 >= deletion.length / 2 ||
                        overlap_length2 >= insertion.length / 2) {
                        // Reverse overlap found.
                        // Insert an equality and swap and trim the surrounding edits.
                        diffs.splice(pointer, 0, [0 /* Equal */, deletion.substring(0, overlap_length2)]);
                        diffs[pointer - 1][0] = 1 /* Insert */;
                        diffs[pointer - 1][1] =
                            insertion.substring(0, insertion.length - overlap_length2);
                        diffs[pointer + 1][0] = -1 /* Delete */;
                        diffs[pointer + 1][1] =
                            deletion.substring(overlap_length2);
                        pointer++;
                    }
                }
                pointer++;
            }
            pointer++;
        }
    }
    ;
    /**
     * Look for single edits surrounded on both sides by equalities
     * which can be shifted sideways to align the edit to a word boundary.
     * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
     * @param {?} diffs Array of diff tuples.
     * @return {?}
     */
    diff_cleanupSemanticLossless(diffs) {
        /**
         * Given two strings, compute a score representing whether the internal
         * boundary falls on logical boundaries.
         * Scores range from 6 (best) to 0 (worst).
         * Closure, but does not reference any external constiables.
         * @param {?} one First string.
         * @param {?} two Second string.
         * @return {?} The score.
         */
        function diff_cleanupSemanticScore_(one, two) {
            if (!one || !two) {
                // Edges are the best.
                return 6;
            }
            /** @type {?} */
            const nonAlphaNumericRegex_ = new RegExp('/[^a-zA-Z0-9]/');
            /** @type {?} */
            const char1 = one.charAt(one.length - 1);
            /** @type {?} */
            const char2 = two.charAt(0);
            /** @type {?} */
            const nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);
            /** @type {?} */
            const nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);
            /** @type {?} */
            const whitespace1 = nonAlphaNumeric1 &&
                char1.match(this.whitespaceRegex_);
            /** @type {?} */
            const whitespace2 = nonAlphaNumeric2 &&
                char2.match(this.whitespaceRegex_);
            /** @type {?} */
            const lineBreak1 = whitespace1 &&
                char1.match(this.linebreakRegex_);
            /** @type {?} */
            const lineBreak2 = whitespace2 &&
                char2.match(this.linebreakRegex_);
            /** @type {?} */
            const blankLine1 = lineBreak1 &&
                one.match(this.blanklineEndRegex_);
            /** @type {?} */
            const blankLine2 = lineBreak2 &&
                two.match(this.blanklineStartRegex_);
            if (blankLine1 || blankLine2) {
                // Five points for blank lines.
                return 5;
            }
            else if (lineBreak1 || lineBreak2) {
                // Four points for line breaks.
                return 4;
            }
            else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
                // Three points for end of sentences.
                return 3;
            }
            else if (whitespace1 || whitespace2) {
                // Two points for whitespace.
                return 2;
            }
            else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
                // One point for non-alphanumeric.
                return 1;
            }
            return 0;
        }
        /** @type {?} */
        let pointer = 1;
        // Intentionally ignore the first and last element (don't need checking).
        while (pointer < diffs.length - 1) {
            if (diffs[pointer - 1][0] == 0 /* Equal */ &&
                diffs[pointer + 1][0] == 0 /* Equal */) {
                /** @type {?} */
                let equality1 = diffs[pointer - 1][1];
                /** @type {?} */
                let edit = diffs[pointer][1];
                /** @type {?} */
                let equality2 = diffs[pointer + 1][1];
                /** @type {?} */
                const commonOffset = this.diff_commonSuffix(equality1, edit);
                if (commonOffset) {
                    /** @type {?} */
                    const commonString = edit.substring(edit.length - commonOffset);
                    equality1 = equality1.substring(0, equality1.length - commonOffset);
                    edit = commonString + edit.substring(0, edit.length - commonOffset);
                    equality2 = commonString + equality2;
                }
                /** @type {?} */
                let bestEquality1 = equality1;
                /** @type {?} */
                let bestEdit = edit;
                /** @type {?} */
                let bestEquality2 = equality2;
                /** @type {?} */
                let bestScore = diff_cleanupSemanticScore_(equality1, edit) +
                    diff_cleanupSemanticScore_(edit, equality2);
                while (edit.charAt(0) === equality2.charAt(0)) {
                    equality1 += edit.charAt(0);
                    edit = edit.substring(1) + equality2.charAt(0);
                    equality2 = equality2.substring(1);
                    /** @type {?} */
                    const score = diff_cleanupSemanticScore_(equality1, edit) +
                        diff_cleanupSemanticScore_(edit, equality2);
                    // The >= encourages trailing rather than leading whitespace on edits.
                    if (score >= bestScore) {
                        bestScore = score;
                        bestEquality1 = equality1;
                        bestEdit = edit;
                        bestEquality2 = equality2;
                    }
                }
                if (diffs[pointer - 1][1] != bestEquality1) {
                    // We have an improvement, save it back to the diff.
                    if (bestEquality1) {
                        diffs[pointer - 1][1] = bestEquality1;
                    }
                    else {
                        diffs.splice(pointer - 1, 1);
                        pointer--;
                    }
                    diffs[pointer][1] = bestEdit;
                    if (bestEquality2) {
                        diffs[pointer + 1][1] = bestEquality2;
                    }
                    else {
                        diffs.splice(pointer + 1, 1);
                        pointer--;
                    }
                }
            }
            pointer++;
        }
    }
    ;
    /**
     * Reduce the number of edits by eliminating operationally trivial equalities.
     * @param {?} diffs Array of diff tuples.
     * @return {?}
     */
    diff_cleanupEfficiency(diffs) {
        /** @type {?} */
        let changes = false;
        /** @type {?} */
        const equalities = [];
        /** @type {?} */
        let equalitiesLength = 0;
        /** @type {?} */
        let lastequality = null;
        /** @type {?} */
        let pointer = 0;
        /** @type {?} */
        let pre_ins = false;
        /** @type {?} */
        let pre_del = false;
        /** @type {?} */
        let post_ins = false;
        /** @type {?} */
        let post_del = false;
        while (pointer < diffs.length) {
            if (diffs[pointer][0] == 0 /* Equal */) {
                // Equality found.
                if (diffs[pointer][1].length < this.Diff_EditCost &&
                    (post_ins || post_del)) {
                    // Candidate found.
                    equalities[equalitiesLength++] = pointer;
                    pre_ins = post_ins;
                    pre_del = post_del;
                    lastequality = diffs[pointer][1];
                }
                else {
                    // Not a candidate, and can never become one.
                    equalitiesLength = 0;
                    lastequality = null;
                }
                post_ins = post_del = false;
            }
            else {
                // An insertion or deletion.
                if (diffs[pointer][0] == -1 /* Delete */) {
                    post_del = true;
                }
                else {
                    post_ins = true;
                }
                /*
                        * Five types to be split:
                        * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
                        * <ins>A</ins>X<ins>C</ins><del>D</del>
                        * <ins>A</ins><del>B</del>X<ins>C</ins>
                        * <ins>A</del>X<ins>C</ins><del>D</del>
                        * <ins>A</ins><del>B</del>X<del>C</del>
                        */
                if (lastequality && ((pre_ins && pre_del && post_ins && post_del) ||
                    ((lastequality.length < this.Diff_EditCost / 2) &&
                        ((pre_ins ? 1 : 0) + (pre_del ? 1 : 0) + (post_ins ? 1 : 0) + (post_del ? 1 : 0) == 3)))) {
                    // Duplicate record.
                    diffs.splice(equalities[equalitiesLength - 1], 0, [-1 /* Delete */, lastequality]);
                    // Change second copy to insert.
                    diffs[equalities[equalitiesLength - 1] + 1][0] = 1 /* Insert */;
                    equalitiesLength--; // Throw away the equality we just deleted;
                    lastequality = null;
                    if (pre_ins && pre_del) {
                        // No changes made which could affect previous entry, keep going.
                        post_ins = post_del = true;
                        equalitiesLength = 0;
                    }
                    else {
                        equalitiesLength--; // Throw away the previous equality.
                        pointer = equalitiesLength > 0 ?
                            equalities[equalitiesLength - 1] : -1;
                        post_ins = post_del = false;
                    }
                    changes = true;
                }
            }
            pointer++;
        }
        if (changes) {
            this.diff_cleanupMerge(diffs);
        }
    }
    ;
    /**
     * Reorder and merge like edit sections.  Merge equalities.
     * Any edit section can move as long as it doesn't cross an equality.
     * @param {?} diffs Array of diff tuples.
     * @return {?}
     */
    diff_cleanupMerge(diffs) {
        diffs.push([0 /* Equal */, '']);
        /** @type {?} */
        let pointer = 0;
        /** @type {?} */
        let count_delete = 0;
        /** @type {?} */
        let count_insert = 0;
        /** @type {?} */
        let text_delete = '';
        /** @type {?} */
        let text_insert = '';
        /** @type {?} */
        let commonlength;
        while (pointer < diffs.length) {
            switch (diffs[pointer][0]) {
                case 1 /* Insert */:
                    count_insert++;
                    text_insert += diffs[pointer][1];
                    pointer++;
                    break;
                case -1 /* Delete */:
                    count_delete++;
                    text_delete += diffs[pointer][1];
                    pointer++;
                    break;
                case 0 /* Equal */:
                    // Upon reaching an equality, check for prior redundancies.
                    if (count_delete + count_insert > 1) {
                        if (count_delete !== 0 && count_insert !== 0) {
                            // Factor out any common prefixies.
                            commonlength = this.diff_commonPrefix(text_insert, text_delete);
                            if (commonlength !== 0) {
                                if ((pointer - count_delete - count_insert) > 0 &&
                                    diffs[pointer - count_delete - count_insert - 1][0] ==
                                        0 /* Equal */) {
                                    diffs[pointer - count_delete - count_insert - 1][1] +=
                                        text_insert.substring(0, commonlength);
                                }
                                else {
                                    diffs.splice(0, 0, [0 /* Equal */,
                                        text_insert.substring(0, commonlength)]);
                                    pointer++;
                                }
                                text_insert = text_insert.substring(commonlength);
                                text_delete = text_delete.substring(commonlength);
                            }
                            // Factor out any common suffixies.
                            commonlength = this.diff_commonSuffix(text_insert, text_delete);
                            if (commonlength !== 0) {
                                diffs[pointer][1] = text_insert.substring(text_insert.length -
                                    commonlength) + diffs[pointer][1];
                                text_insert = text_insert.substring(0, text_insert.length -
                                    commonlength);
                                text_delete = text_delete.substring(0, text_delete.length -
                                    commonlength);
                            }
                        }
                        // Delete the offending records and add the merged ones.
                        if (count_delete === 0) {
                            diffs.splice(pointer - count_insert, count_delete + count_insert, [1 /* Insert */, text_insert]);
                        }
                        else if (count_insert === 0) {
                            diffs.splice(pointer - count_delete, count_delete + count_insert, [-1 /* Delete */, text_delete]);
                        }
                        else {
                            diffs.splice(pointer - count_delete - count_insert, count_delete + count_insert, [-1 /* Delete */, text_delete], [1 /* Insert */, text_insert]);
                        }
                        pointer = pointer - count_delete - count_insert +
                            (count_delete ? 1 : 0) + (count_insert ? 1 : 0) + 1;
                    }
                    else if (pointer !== 0 && diffs[pointer - 1][0] == 0 /* Equal */) {
                        // Merge this equality with the previous one.
                        diffs[pointer - 1][1] += diffs[pointer][1];
                        diffs.splice(pointer, 1);
                    }
                    else {
                        pointer++;
                    }
                    count_insert = 0;
                    count_delete = 0;
                    text_delete = '';
                    text_insert = '';
                    break;
            }
        }
        if (diffs[diffs.length - 1][1] === '') {
            diffs.pop(); // Remove the dummy entry at the end.
        }
        /** @type {?} */
        let changes = false;
        pointer = 1;
        // Intentionally ignore the first and last element (don't need checking).
        while (pointer < diffs.length - 1) {
            if (diffs[pointer - 1][0] == 0 /* Equal */ &&
                diffs[pointer + 1][0] == 0 /* Equal */) {
                // This is a single edit surrounded by equalities.
                if (diffs[pointer][1].substring(diffs[pointer][1].length -
                    diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {
                    // Shift the edit over the previous equality.
                    diffs[pointer][1] = diffs[pointer - 1][1] +
                        diffs[pointer][1].substring(0, diffs[pointer][1].length -
                            diffs[pointer - 1][1].length);
                    diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
                    diffs.splice(pointer - 1, 1);
                    changes = true;
                }
                else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==
                    diffs[pointer + 1][1]) {
                    // Shift the edit over the next equality.
                    diffs[pointer - 1][1] += diffs[pointer + 1][1];
                    diffs[pointer][1] =
                        diffs[pointer][1].substring(diffs[pointer + 1][1].length) +
                            diffs[pointer + 1][1];
                    diffs.splice(pointer + 1, 1);
                    changes = true;
                }
            }
            pointer++;
        }
        // If shifts were made, the diff needs reordering and another shift sweep.
        if (changes) {
            this.diff_cleanupMerge(diffs);
        }
    }
    ;
    /**
     * loc is a location in text1, compute and return the equivalent location in
     * text2.
     * e.g. 'The cat' vs 'The big cat', 1->1, 5->8
     * @param {?} diffs Array of diff tuples.
     * @param {?} loc Location within text1.
     * @return {?} Location within text2.
     */
    diff_xIndex(diffs, loc) {
        /** @type {?} */
        let chars1 = 0;
        /** @type {?} */
        let chars2 = 0;
        /** @type {?} */
        let last_chars1 = 0;
        /** @type {?} */
        let last_chars2 = 0;
        /** @type {?} */
        let x;
        for (x = 0; x < diffs.length; x++) {
            if (diffs[x][0] !== 1 /* Insert */) {
                // Equality or deletion.
                chars1 += diffs[x][1].length;
            }
            if (diffs[x][0] !== -1 /* Delete */) {
                // Equality or insertion.
                chars2 += diffs[x][1].length;
            }
            if (chars1 > loc) {
                // Overshot the location.
                break;
            }
            last_chars1 = chars1;
            last_chars2 = chars2;
        }
        // Was the location was deleted?
        if (diffs.length != x && diffs[x][0] === -1 /* Delete */) {
            return last_chars2;
        }
        // Add the remaining character length.
        return last_chars2 + (loc - last_chars1);
    }
    ;
    /**
     * Compute and return the source text (all equalities and deletions).
     * @param {?} diffs Array of diff tuples.
     * @return {?} Source text.
     */
    diff_text1(diffs) {
        /** @type {?} */
        const text = [];
        for (let x = 0; x < diffs.length; x++) {
            if (diffs[x][0] !== 1 /* Insert */) {
                text[x] = diffs[x][1];
            }
        }
        return text.join('');
    }
    ;
    /**
     * Compute and return the destination text (all equalities and insertions).
     * @param {?} diffs Array of diff tuples.
     * @return {?} Destination text.
     */
    diff_text2(diffs) {
        /** @type {?} */
        const text = [];
        for (let x = 0; x < diffs.length; x++) {
            if (diffs[x][0] !== -1 /* Delete */) {
                text[x] = diffs[x][1];
            }
        }
        return text.join('');
    }
    ;
    /**
     * Compute the Levenshtein distance; the number of inserted, deleted or
     * substituted characters.
     * @param {?} diffs Array of diff tuples.
     * @return {?} Number of changes.
     */
    diff_levenshtein(diffs) {
        /** @type {?} */
        let levenshtein = 0;
        /** @type {?} */
        let insertions = 0;
        /** @type {?} */
        let deletions = 0;
        for (let x = 0; x < diffs.length; x++) {
            /** @type {?} */
            const op = diffs[x][0];
            /** @type {?} */
            const data = diffs[x][1];
            switch (op) {
                case 1 /* Insert */:
                    insertions += data.length;
                    break;
                case -1 /* Delete */:
                    deletions += data.length;
                    break;
                case 0 /* Equal */:
                    // A deletion and an insertion is one substitution.
                    levenshtein += Math.max(insertions, deletions);
                    insertions = 0;
                    deletions = 0;
                    break;
            }
        }
        levenshtein += Math.max(insertions, deletions);
        return levenshtein;
    }
    ;
    /**
     * Crush the diff into an encoded string which describes the operations
     * required to transform text1 into text2.
     * E.g. =3\t-2\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.
     * Operations are tab-separated.  Inserted text is escaped using %xx notation.
     * @param {?} diffs Array of diff tuples.
     * @return {?} Delta text.
     */
    diff_toDelta(diffs) {
        /** @type {?} */
        const text = [];
        for (let x = 0; x < diffs.length; x++) {
            switch (diffs[x][0]) {
                case 1 /* Insert */:
                    text[x] = '+' + encodeURI(diffs[x][1]);
                    break;
                case -1 /* Delete */:
                    text[x] = '-' + diffs[x][1].length;
                    break;
                case 0 /* Equal */:
                    text[x] = '=' + diffs[x][1].length;
                    break;
            }
        }
        return text.join('\t').replace(/%20/g, ' ');
    }
    ;
    /**
     * Given the original text1, and an encoded string which describes the
     * operations required to transform text1 into text2, compute the full diff.
     * @throws {!Error} If invalid input.
     * @param {?} text1 Source string for the diff.
     * @param {?} delta Delta text.
     * @return {?} Array of diff tuples.
     */
    diff_fromDelta(text1, delta) {
        /** @type {?} */
        const diffs = [];
        /** @type {?} */
        let diffsLength = 0;
        /** @type {?} */
        let pointer = 0;
        /** @type {?} */
        const tokens = delta.split(/\t/g);
        for (let x = 0; x < tokens.length; x++) {
            /** @type {?} */
            const param = tokens[x].substring(1);
            switch (tokens[x].charAt(0)) {
                case '+':
                    try {
                        diffs[diffsLength++] = [1 /* Insert */, decodeURI(param)];
                    }
                    catch (ex) {
                        // Malformed URI sequence.
                        throw new Error('Illegal escape in diff_fromDelta: ' + param);
                    }
                    break;
                case '-':
                // Fall through.
                case '=':
                    /** @type {?} */
                    const n = parseInt(param, 10);
                    if (isNaN(n) || n < 0) {
                        throw new Error('Invalid number in diff_fromDelta: ' + param);
                    }
                    /** @type {?} */
                    const text = text1.substring(pointer, pointer += n);
                    if (tokens[x].charAt(0) == '=') {
                        diffs[diffsLength++] = [0 /* Equal */, text];
                    }
                    else {
                        diffs[diffsLength++] = [-1 /* Delete */, text];
                    }
                    break;
                default:
                    // Blank tokens are ok (from a trailing \t).
                    // Anything else is an error.
                    if (tokens[x]) {
                        throw new Error('Invalid diff operation in diff_fromDelta: ' +
                            tokens[x]);
                    }
            }
        }
        if (pointer != text1.length) {
            throw new Error('Delta length (' + pointer +
                ') does not equal source text length (' + text1.length + ').');
        }
        return diffs;
    }
    ;
    /**
     * Locate the best instance of 'pattern' in 'text' near 'loc'.
     * @param {?} text The text to search.
     * @param {?} pattern The pattern to search for.
     * @param {?} loc The location to search around.
     * @return {?} Best match index or -1.
     */
    match_main(text, pattern, loc) {
        // Check for null inputs.
        if (text == null || pattern == null || loc == null) {
            throw new Error('Null input. (match_main)');
        }
        loc = Math.max(0, Math.min(loc, text.length));
        if (text == pattern) {
            // Shortcut (potentially not guaranteed by the algorithm)
            return 0;
        }
        else if (!text.length) {
            // Nothing to match.
            return -1;
        }
        else if (text.substring(loc, loc + pattern.length) == pattern) {
            // Perfect match at the perfect spot!  (Includes case of null pattern)
            return loc;
        }
        else {
            // Do a fuzzy compare.
            return this.match_bitap_(text, pattern, loc);
        }
    }
    ;
    /**
     * Locate the best instance of 'pattern' in 'text' near 'loc' using the
     * Bitap algorithm.
     * @param {?} text The text to search.
     * @param {?} pattern The pattern to search for.
     * @param {?} loc The location to search around.
     * @return {?} Best match index or -1.
     */
    match_bitap_(text, pattern, loc) {
        if (pattern.length > this.Match_MaxBits) {
            throw new Error('Pattern too long for this browser.');
        }
        /** @type {?} */
        const s = this.match_alphabet_(pattern);
        /** @type {?} */
        const dmp = this;
        /**
         * Compute and return the score for a match with e errors and x location.
         * Accesses loc and pattern through being a closure.
         * @param {?} e Number of errors in match.
         * @param {?} x Location of match.
         * @return {?} Overall score for match (0.0 = good, 1.0 = bad).
         */
        function match_bitapScore_(e, x) {
            /** @type {?} */
            const accuracy = e / pattern.length;
            /** @type {?} */
            const proximity = Math.abs(loc - x);
            if (!dmp.Match_Distance) {
                // Dodge divide by zero error.
                return proximity ? 1.0 : accuracy;
            }
            return accuracy + (proximity / dmp.Match_Distance);
        }
        /** @type {?} */
        let score_threshold = this.Match_Threshold;
        /** @type {?} */
        let best_loc = text.indexOf(pattern, loc);
        if (best_loc != -1) {
            score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold);
            // What about in the other direction? (speedup)
            best_loc = text.lastIndexOf(pattern, loc + pattern.length);
            if (best_loc != -1) {
                score_threshold =
                    Math.min(match_bitapScore_(0, best_loc), score_threshold);
            }
        }
        /** @type {?} */
        const matchmask = 1 << (pattern.length - 1);
        best_loc = -1;
        /** @type {?} */
        let bin_min;
        /** @type {?} */
        let bin_mid;
        /** @type {?} */
        let bin_max = pattern.length + text.length;
        /** @type {?} */
        let last_rd;
        for (let d = 0; d < pattern.length; d++) {
            // Scan for the best match; each iteration allows for one more error.
            // Run a binary search to determine how far from 'loc' we can stray at this
            // error level.
            bin_min = 0;
            bin_mid = bin_max;
            while (bin_min < bin_mid) {
                if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) {
                    bin_min = bin_mid;
                }
                else {
                    bin_max = bin_mid;
                }
                bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);
            }
            // Use the result from this iteration as the maximum for the next.
            bin_max = bin_mid;
            /** @type {?} */
            let start = Math.max(1, loc - bin_mid + 1);
            /** @type {?} */
            const finish = Math.min(loc + bin_mid, text.length) + pattern.length;
            /** @type {?} */
            const rd = Array(finish + 2);
            rd[finish + 1] = (1 << d) - 1;
            for (let j = finish; j >= start; j--) {
                /** @type {?} */
                const charMatch = s[text.charAt(j - 1)];
                if (d === 0) {
                    // First pass: exact match.
                    rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;
                }
                else {
                    // Subsequent passes: fuzzy match.
                    rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) |
                        (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |
                        last_rd[j + 1];
                }
                if (rd[j] & matchmask) {
                    /** @type {?} */
                    const score = match_bitapScore_(d, j - 1);
                    // This match will almost certainly be better than any existing match.
                    // But check anyway.
                    if (score <= score_threshold) {
                        // Told you so.
                        score_threshold = score;
                        best_loc = j - 1;
                        if (best_loc > loc) {
                            // When passing loc, don't exceed our current distance from loc.
                            start = Math.max(1, 2 * loc - best_loc);
                        }
                        else {
                            // Already passed loc, downhill from here on in.
                            break;
                        }
                    }
                }
            }
            // No hope for a (better) match at greater error levels.
            if (match_bitapScore_(d + 1, loc) > score_threshold) {
                break;
            }
            last_rd = rd;
        }
        return best_loc;
    }
    ;
    /**
     * Initialise the alphabet for the Bitap algorithm.
     * @param {?} pattern The text to encode.
     * @return {?} Hash of character locations.
     */
    match_alphabet_(pattern) {
        /** @type {?} */
        const s = {};
        for (let i = 0; i < pattern.length; i++) {
            s[pattern.charAt(i)] = 0;
        }
        for (let i = 0; i < pattern.length; i++) {
            s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);
        }
        return s;
    }
    ;
    /**
     * Increase the context until it is unique,
     * but don't let the pattern expand beyond Match_MaxBits.
     * @param {?} patch The patch to grow.
     * @param {?} text Source text.
     * @return {?}
     */
    patch_addContext_(patch, text) {
        if (text.length == 0) {
            return;
        }
        /** @type {?} */
        let pattern = text.substring(patch.start2, patch.start2 + patch.length1);
        /** @type {?} */
        let padding = 0;
        // Look for the first and last matches of pattern in text.  If two different
        // matches are found, increase the pattern length.
        while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&
            pattern.length < this.Match_MaxBits - this.Patch_Margin -
                this.Patch_Margin) {
            padding += this.Patch_Margin;
            pattern = text.substring(patch.start2 - padding, patch.start2 + patch.length1 + padding);
        }
        // Add one chunk for good luck.
        padding += this.Patch_Margin;
        /** @type {?} */
        const prefix = text.substring(patch.start2 - padding, patch.start2);
        if (prefix) {
            patch.diffs.unshift([0 /* Equal */, prefix]);
        }
        /** @type {?} */
        const suffix = text.substring(patch.start2 + patch.length1, patch.start2 + patch.length1 + padding);
        if (suffix) {
            patch.diffs.push([0 /* Equal */, suffix]);
        }
        // Roll back the start points.
        patch.start1 -= prefix.length;
        patch.start2 -= prefix.length;
        // Extend the lengths.
        patch.length1 += prefix.length + suffix.length;
        patch.length2 += prefix.length + suffix.length;
    }
    ;
    /**
     * Compute a list of patches to turn text1 into text2.
     * Use diffs if provided, otherwise compute it ourselves.
     * There are four ways to call this function, depending on what data is
     * available to the caller:
     * Method 1:
     * a = text1, b = text2
     * Method 2:
     * a = diffs
     * Method 3 (optimal):
     * a = text1, b = diffs
     * Method 4 (deprecated, use method 3):
     * a = text1, b = text2, c = diffs
     *
     * @param {?} a text1 (methods 1,3,4) or
     * Array of diff tuples for text1 to text2 (method 2).
     * @param {?} opt_b text2 (methods 1,4) or
     * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).
     * @param {?} opt_c Array of diff tuples
     * for text1 to text2 (method 4) or undefined (methods 1,2,3).
     * @return {?} Array of Patch objects.
     */
    patch_make(a, opt_b, opt_c) {
        /** @type {?} */
        let text1;
        /** @type {?} */
        let diffs;
        if (typeof a == 'string' && typeof opt_b == 'string' &&
            typeof opt_c == 'undefined') {
            // Method 1: text1, text2
            // Compute diffs from text1 and text2.
            text1 = (a);
            diffs = this.diff_main(text1, (opt_b), true);
            if (diffs.length > 2) {
                this.diff_cleanupSemantic(diffs);
                this.diff_cleanupEfficiency(diffs);
            }
        }
        else if (a && typeof a == 'object' && typeof opt_b == 'undefined' &&
            typeof opt_c == 'undefined') {
            // Method 2: diffs
            // Compute text1 from diffs.
            diffs = (a);
            text1 = this.diff_text1(diffs);
        }
        else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' &&
            typeof opt_c == 'undefined') {
            // Method 3: text1, diffs
            text1 = (a);
            diffs = (opt_b);
        }
        else if (typeof a == 'string' && typeof opt_b == 'string' &&
            opt_c && typeof opt_c == 'object') {
            // Method 4: text1, text2, diffs
            // text2 is not used.
            text1 = (a);
            diffs = (opt_c);
        }
        else {
            throw new Error('Unknown call format to patch_make.');
        }
        if (diffs.length === 0) {
            return []; // Get rid of the null case.
        }
        /** @type {?} */
        const patches = [];
        /** @type {?} */
        let patch = new patch_obj();
        /** @type {?} */
        let patchDiffLength = 0;
        /** @type {?} */
        let char_count1 = 0;
        /** @type {?} */
        let char_count2 = 0;
        /** @type {?} */
        let prepatch_text = text1;
        /** @type {?} */
        let postpatch_text = text1;
        for (let x = 0; x < diffs.length; x++) {
            /** @type {?} */
            const diff_type = diffs[x][0];
            /** @type {?} */
            const diff_text = diffs[x][1];
            if (!patchDiffLength && diff_type !== 0 /* Equal */) {
                // A new patch starts here.
                patch.start1 = char_count1;
                patch.start2 = char_count2;
            }
            switch (diff_type) {
                case 1 /* Insert */:
                    patch.diffs[patchDiffLength++] = diffs[x];
                    patch.length2 += diff_text.length;
                    postpatch_text = postpatch_text.substring(0, char_count2) + diff_text +
                        postpatch_text.substring(char_count2);
                    break;
                case -1 /* Delete */:
                    patch.length1 += diff_text.length;
                    patch.diffs[patchDiffLength++] = diffs[x];
                    postpatch_text = postpatch_text.substring(0, char_count2) +
                        postpatch_text.substring(char_count2 +
                            diff_text.length);
                    break;
                case 0 /* Equal */:
                    if (diff_text.length <= 2 * this.Patch_Margin &&
                        patchDiffLength && diffs.length != x + 1) {
                        // Small equality inside a patch.
                        patch.diffs[patchDiffLength++] = diffs[x];
                        patch.length1 += diff_text.length;
                        patch.length2 += diff_text.length;
                    }
                    else if (diff_text.length >= 2 * this.Patch_Margin) {
                        // Time for a new patch.
                        if (patchDiffLength) {
                            this.patch_addContext_(patch, prepatch_text);
                            patches.push(patch);
                            patch = new patch_obj();
                            patchDiffLength = 0;
                            // Unlike Unidiff, our patch lists have a rolling context.
                            // http://code.google.com/p/google-diff-match-patch/wiki/Unidiff
                            // Update prepatch text & pos to reflect the application of the
                            // just completed patch.
                            prepatch_text = postpatch_text;
                            char_count1 = char_count2;
                        }
                    }
                    break;
            }
            // Update the current character count.
            if (diff_type !== 1 /* Insert */) {
                char_count1 += diff_text.length;
            }
            if (diff_type !== -1 /* Delete */) {
                char_count2 += diff_text.length;
            }
        }
        // Pick up the leftover patch if not empty.
        if (patchDiffLength) {
            this.patch_addContext_(patch, prepatch_text);
            patches.push(patch);
        }
        return patches;
    }
    ;
    /**
     * Given an array of patches, return another array that is identical.
     * @param {?} patches Array of Patch objects.
     * @return {?} Array of Patch objects.
     */
    patch_deepCopy(patches) {
        /** @type {?} */
        const patchesCopy = [];
        for (let x = 0; x < patches.length; x++) {
            /** @type {?} */
            const patch = patches[x];
            /** @type {?} */
            const patchCopy = new patch_obj();
            patchCopy.diffs = [];
            for (let y = 0; y < patch.diffs.length; y++) {
                patchCopy.diffs[y] = [patch.diffs[y][0], patch.diffs[y][1]];
            }
            patchCopy.start1 = patch.start1;
            patchCopy.start2 = patch.start2;
            patchCopy.length1 = patch.length1;
            patchCopy.length2 = patch.length2;
            patchesCopy[x] = patchCopy;
        }
        return patchesCopy;
    }
    ;
    /**
     * Merge a set of patches onto the text.  Return a patched text, as well
     * as a list of true/false values indicating which patches were applied.
     * @param {?} patches Array of Patch objects.
     * @param {?} text Old text.
     * @return {?} Two element Array, containing the
     *      new text and an array of boolean values.
     */
    patch_apply(patches, text) {
        if (patches.length == 0) {
            return [text, []];
        }
        // Deep copy the patches so that no changes are made to originals.
        patches = this.patch_deepCopy(patches);
        /** @type {?} */
        const nullPadding = this.patch_addPadding(patches);
        text = nullPadding + text + nullPadding;
        this.patch_splitMax(patches);
        /** @type {?} */
        let delta = 0;
        /** @type {?} */
        const results = [];
        for (let x = 0; x < patches.length; x++) {
            /** @type {?} */
            const expected_loc = patches[x].start2 + delta;
            /** @type {?} */
            const text1 = this.diff_text1(patches[x].diffs);
            /** @type {?} */
            let start_loc;
            /** @type {?} */
            let end_loc = -1;
            if (text1.length > this.Match_MaxBits) {
                // patch_splitMax will only provide an oversized pattern in the case of
                // a monster delete.
                start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits), expected_loc);
                if (start_loc != -1) {
                    end_loc = this.match_main(text, text1.substring(text1.length - this.Match_MaxBits), expected_loc + text1.length - this.Match_MaxBits);
                    if (end_loc == -1 || start_loc >= end_loc) {
                        // Can't find valid trailing context.  Drop this patch.
                        start_loc = -1;
                    }
                }
            }
            else {
                start_loc = this.match_main(text, text1, expected_loc);
            }
            if (start_loc == -1) {
                // No match found.  :(
                results[x] = false;
                // Subtract the delta for this failed patch from subsequent patches.
                delta -= patches[x].length2 - patches[x].length1;
            }
            else {
                // Found a match.  :)
                results[x] = true;
                delta = start_loc - expected_loc;
                /** @type {?} */
                let text2;
                if (end_loc == -1) {
                    text2 = text.substring(start_loc, start_loc + text1.length);
                }
                else {
                    text2 = text.substring(start_loc, end_loc + this.Match_MaxBits);
                }
                if (text1 == text2) {
                    // Perfect match, just shove the replacement text in.
                    text = text.substring(0, start_loc) +
                        this.diff_text2(patches[x].diffs) +
                        text.substring(start_loc + text1.length);
                }
                else {
                    /** @type {?} */
                    const diffs = this.diff_main(text1, text2, false);
                    if (text1.length > this.Match_MaxBits &&
                        this.diff_levenshtein(diffs) / text1.length >
                            this.Patch_DeleteThreshold) {
                        // The end points match, but the content is unacceptably bad.
                        results[x] = false;
                    }
                    else {
                        this.diff_cleanupSemanticLossless(diffs);
                        /** @type {?} */
                        let index1 = 0;
                        /** @type {?} */
                        let index2;
                        for (let y = 0; y < patches[x].diffs.length; y++) {
                            /** @type {?} */
                            const mod = patches[x].diffs[y];
                            if (mod[0] !== 0 /* Equal */) {
                                index2 = this.diff_xIndex(diffs, index1);
                            }
                            if (mod[0] === 1 /* Insert */) {
                                // Insertion
                                text = text.substring(0, start_loc + index2) + mod[1] +
                                    text.substring(start_loc + index2);
                            }
                            else if (mod[0] === -1 /* Delete */) {
                                // Deletion
                                text = text.substring(0, start_loc + index2) +
                                    text.substring(start_loc + this.diff_xIndex(diffs, index1 + mod[1].length));
                            }
                            if (mod[0] !== -1 /* Delete */) {
                                index1 += mod[1].length;
                            }
                        }
                    }
                }
            }
        }
        // Strip the padding off.
        text = text.substring(nullPadding.length, text.length - nullPadding.length);
        return [text, results];
    }
    ;
    /**
     * Add some padding on text start and end so that edges can match something.
     * Intended to be called only from within patch_apply.
     * @param {?} patches Array of Patch objects.
     * @return {?} The padding string added to each side.
     */
    patch_addPadding(patches) {
        /** @type {?} */
        const paddingLength = this.Patch_Margin;
        /** @type {?} */
        let nullPadding = '';
        for (let x = 1; x <= paddingLength; x++) {
            nullPadding += String.fromCharCode(x);
        }
        // Bump all the patches forward.
        for (let x = 0; x < patches.length; x++) {
            patches[x].start1 += paddingLength;
            patches[x].start2 += paddingLength;
        }
        /** @type {?} */
        let patch = patches[0];
        /** @type {?} */
        let diffs = patch.diffs;
        if (diffs.length == 0 || diffs[0][0] != 0 /* Equal */) {
            // Add nullPadding equality.
            diffs.unshift([0 /* Equal */, nullPadding]);
            patch.start1 -= paddingLength; // Should be 0.
            patch.start2 -= paddingLength; // Should be 0.
            patch.length1 += paddingLength;
            patch.length2 += paddingLength;
        }
        else if (paddingLength > diffs[0][1].length) {
            /** @type {?} */
            const extraLength = paddingLength - diffs[0][1].length;
            diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1];
            patch.start1 -= extraLength;
            patch.start2 -= extraLength;
            patch.length1 += extraLength;
            patch.length2 += extraLength;
        }
        // Add some padding on end of last diff.
        patch = patches[patches.length - 1];
        diffs = patch.diffs;
        if (diffs.length == 0 || diffs[diffs.length - 1][0] != 0 /* Equal */) {
            // Add nullPadding equality.
            diffs.push([0 /* Equal */, nullPadding]);
            patch.length1 += paddingLength;
            patch.length2 += paddingLength;
        }
        else if (paddingLength > diffs[diffs.length - 1][1].length) {
            /** @type {?} */
            const extraLength = paddingLength - diffs[diffs.length - 1][1].length;
            diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength);
            patch.length1 += extraLength;
            patch.length2 += extraLength;
        }
        return nullPadding;
    }
    ;
    /**
     * Take a list of patches and return a textual representation.
     * @param {?} patches Array of Patch objects.
     * @return {?} Text representation of patches.
     */
    patch_toText(patches) {
        /** @type {?} */
        const text = [];
        for (let x = 0; x < patches.length; x++) {
            text[x] = patches[x];
        }
        return text.join('');
    }
    ;
    /**
     * Parse a textual representation of patches and return a list of Patch objects.
     * @throws {!Error} If invalid input.
     * @param {?} textline Text representation of patches.
     * @return {?} Array of Patch objects.
     */
    patch_fromText(textline) {
        /** @type {?} */
        const patches = [];
        if (!textline) {
            return patches;
        }
        /** @type {?} */
        const text = textline.split('\n');
        /** @type {?} */
        let textPointer = 0;
        /** @type {?} */
        const patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
        while (textPointer < text.length) {
            /** @type {?} */
            const m = text[textPointer].match(patchHeader);
            if (!m) {
                throw new Error('Invalid patch string: ' + text[textPointer]);
            }
            /** @type {?} */
            const patch = new patch_obj();
            patches.push(patch);
            patch.start1 = parseInt(m[1], 10);
            if (m[2] === '') {
                patch.start1--;
                patch.length1 = 1;
            }
            else if (m[2] == '0') {
                patch.length1 = 0;
            }
            else {
                patch.start1--;
                patch.length1 = parseInt(m[2], 10);
            }
            patch.start2 = parseInt(m[3], 10);
            if (m[4] === '') {
                patch.start2--;
                patch.length2 = 1;
            }
            else if (m[4] == '0') {
                patch.length2 = 0;
            }
            else {
                patch.start2--;
                patch.length2 = parseInt(m[4], 10);
            }
            textPointer++;
            while (textPointer < text.length) {
                /** @type {?} */
                const sign = text[textPointer].charAt(0);
                /** @type {?} */
                let line;
                try {
                    line = decodeURI(text[textPointer].substring(1));
                }
                catch (ex) {
                    // Malformed URI sequence.
                    throw new Error('Illegal escape in patch_fromText: ' + line);
                }
                if (sign == '-') {
                    // Deletion.
                    patch.diffs.push([-1 /* Delete */, line]);
                }
                else if (sign == '+') {
                    // Insertion.
                    patch.diffs.push([1 /* Insert */, line]);
                }
                else if (sign == ' ') {
                    // Minor equality.
                    patch.diffs.push([0 /* Equal */, line]);
                }
                else if (sign == '@') {
                    // Start of next patch.
                    break;
                }
                else if (sign === '') {
                    // Blank line?  Whatever.
                }
                else {
                    // WTF?
                    throw new Error('Invalid patch mode "' + sign + '" in: ' + line);
                }
                textPointer++;
            }
        }
        return patches;
    }
    ;
}
if (false) {
    /** @type {?} */
    DiffMatchPatch.prototype.Diff_Timeout;
    /** @type {?} */
    DiffMatchPatch.prototype.Diff_EditCost;
    /** @type {?} */
    DiffMatchPatch.prototype.Match_Threshold;
    /** @type {?} */
    DiffMatchPatch.prototype.Match_Distance;
    /** @type {?} */
    DiffMatchPatch.prototype.Patch_DeleteThreshold;
    /** @type {?} */
    DiffMatchPatch.prototype.Patch_Margin;
    /** @type {?} */
    DiffMatchPatch.prototype.Match_MaxBits;
    /**
     * The data structure representing a diff is an array of tuples:
     * [[DiffOp.Delete, 'Hello'], [DiffOp.Insert, 'Goodbye'], [DiffOp.Equal, ' world.']]
     * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
     * @type {?}
     */
    DiffMatchPatch.prototype.whitespaceRegex_;
    /** @type {?} */
    DiffMatchPatch.prototype.linebreakRegex_;
    /** @type {?} */
    DiffMatchPatch.prototype.blanklineEndRegex_;
    /** @type {?} */
    DiffMatchPatch.prototype.blanklineStartRegex_;
    /**
     * Convert a diff array into a pretty HTML report.
     * \@param diffs Array of diff tuples.
     * \@return HTML representation.
     * @type {?}
     */
    DiffMatchPatch.prototype.diff_prettyHtml;
    /**
     * Look through the patches and break up any which are longer than the maximum
     * limit of the match algorithm.
     * Intended to be called only from within patch_apply.
     * \@param patches Array of Patch objects.
     * @type {?}
     */
    DiffMatchPatch.prototype.patch_splitMax;
}
/**
 * Class representing one patch operation.
 */
export class patch_obj {
    constructor() {
        this.diffs = [];
        this.start1 = null;
        this.start2 = null;
        this.length1 = 0;
        this.length2 = 0;
        /**
         * Emmulate GNU diff's format.
         * Header: \@\@ -382,8 +481,9 \@\@
         * Indicies are printed as 1-based, not 0-based.
         */
        this.toString = function () {
            /** @type {?} */
            let coords1;
            /** @type {?} */
            let coords2;
            if (this.length1 === 0) {
                coords1 = this.start1 + ',0';
            }
            else if (this.length1 == 1) {
                coords1 = this.start1 + 1;
            }
            else {
                coords1 = (this.start1 + 1) + ',' + this.length1;
            }
            if (this.length2 === 0) {
                coords2 = this.start2 + ',0';
            }
            else if (this.length2 == 1) {
                coords2 = this.start2 + 1;
            }
            else {
                coords2 = (this.start2 + 1) + ',' + this.length2;
            }
            /** @type {?} */
            const text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\n'];
            /** @type {?} */
            let op;
            // Escape the body of the patch with %xx notation.
            for (let x = 0; x < this.diffs.length; x++) {
                switch (this.diffs[x][0]) {
                    case 1 /* Insert */:
                        op = '+';
                        break;
                    case -1 /* Delete */:
                        op = '-';
                        break;
                    case 0 /* Equal */:
                        op = ' ';
                        break;
                }
                text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\n';
            }
            return text.join('').replace(/%20/g, ' ');
        };
    }
}
if (false) {
    /** @type {?} */
    patch_obj.prototype.diffs;
    /** @type {?} */
    patch_obj.prototype.start1;
    /** @type {?} */
    patch_obj.prototype.start2;
    /** @type {?} */
    patch_obj.prototype.length1;
    /** @type {?} */
    patch_obj.prototype.length2;
    /**
     * Emmulate GNU diff's format.
     * Header: \@\@ -382,8 +481,9 \@\@
     * Indicies are printed as 1-based, not 0-based.
     * @type {?}
     */
    patch_obj.prototype.toString;
}
export { DiffMatchPatch };

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