{"version":3,"file":"bundle.js","sources":["/source-files/jsondiffpatch/node_modules/fiberglass/node_modules/browserify/node_modules/browser-pack/_prelude.js","/source-files/jsondiffpatch/src/main-full.js","/source-files/jsondiffpatch/src/environment.js","/source-files/jsondiffpatch/src/main.js","/source-files/jsondiffpatch/public/external/diff_match_patch_uncompressed.js","/source-files/jsondiffpatch/src/diffpatcher.js","/source-files/jsondiffpatch/src/date-reviver.js","/source-files/jsondiffpatch/src/processor.js","/source-files/jsondiffpatch/src/pipe.js","/source-files/jsondiffpatch/src/contexts/diff.js","/source-files/jsondiffpatch/src/contexts/reverse.js","/source-files/jsondiffpatch/src/contexts/patch.js","/source-files/jsondiffpatch/src/filters/trivial.js","/source-files/jsondiffpatch/src/filters/nested.js","/source-files/jsondiffpatch/src/filters/arrays.js","/source-files/jsondiffpatch/src/filters/dates.js","/source-files/jsondiffpatch/src/filters/texts.js","/source-files/jsondiffpatch/src/contexts/context.js","/source-files/jsondiffpatch/src/filters/lcs.js"],"names":["exports","isBrowser","window","environment","require","DiffPatcher","create","options","dateReviver","defaultInstance","diff","apply","arguments","patch","unpatch","reverse","homepage","version","packageInfoModuleName","packageInfo","formatterModuleName","formatters","console","diff_match_patch","this","Diff_Timeout","Diff_EditCost","Match_Threshold","Match_Distance","Patch_DeleteThreshold","Patch_Margin","Match_MaxBits","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","Diff","prototype","diff_main","text1","text2","opt_checklines","opt_deadline","Number","MAX_VALUE","Date","getTime","deadline","Error","checklines","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","length","diffs","diff_compute_","unshift","push","diff_cleanupMerge","longtext","shorttext","i","indexOf","hm","diff_halfMatch_","text1_a","text1_b","text2_a","text2_b","mid_common","diffs_a","diffs_b","concat","diff_lineMode_","diff_bisect_","a","diff_linesToChars_","linearray","diff_charsToLines_","diff_cleanupSemantic","pointer","count_delete","count_insert","text_delete","text_insert","splice","j","pop","text1_length","text2_length","max_d","Math","ceil","v_offset","v_length","v1","Array","v2","x","delta","front","k1start","k1end","k2start","k2end","d","k1","x1","k1_offset","y1","charAt","k2_offset","x2","diff_bisectSplit_","k2","y2","y","text1a","text2a","text1b","text2b","diffsb","diff_linesToCharsMunge_","text","chars","lineStart","lineEnd","lineArrayLength","lineArray","line","lineHash","hasOwnProperty","undefined","String","fromCharCode","chars1","chars2","charCodeAt","join","pointermin","pointermax","min","pointermid","pointerstart","floor","pointerend","diff_commonOverlap_","text_length","best","pattern","found","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","best_common","prefixLength","dmp","suffixLength","hm1","hm2","changes","equalities","equalitiesLength","lastequality","length_insertions1","length_deletions1","length_insertions2","length_deletions2","max","diff_cleanupSemanticLossless","deletion","insertion","overlap_length","diff_cleanupSemanticScore_","one","two","score","match","punctuation","whitespace","linebreak","blanklineEnd","blanklineStart","equality1","edit","equality2","commonOffset","commonString","bestEquality1","bestEdit","bestEquality2","bestScore","diff_cleanupEfficiency","pre_ins","pre_del","post_ins","post_del","diff_xIndex","loc","last_chars1","last_chars2","diff_prettyHtml","html","pattern_amp","pattern_lt","pattern_gt","pattern_para","op","data","replace","diff_text1","diff_text2","diff_levenshtein","levenshtein","insertions","deletions","diff_toDelta","encodeURI","diff_fromDelta","diffsLength","tokens","split","param","decodeURI","ex","n","parseInt","isNaN","match_main","match_bitap_","match_bitapScore_","e","accuracy","proximity","abs","s","match_alphabet_","score_threshold","best_loc","lastIndexOf","matchmask","bin_min","bin_mid","last_rd","bin_max","start","finish","rd","charMatch","patch_addContext_","start2","length1","padding","prefix","suffix","start1","length2","patch_make","opt_b","opt_c","patches","patch_obj","patchDiffLength","char_count1","char_count2","prepatch_text","postpatch_text","diff_type","diff_text","patch_deepCopy","patchesCopy","patchCopy","slice","patch_apply","nullPadding","patch_addPadding","patch_splitMax","results","start_loc","expected_loc","end_loc","index2","index1","mod","paddingLength","extraLength","patch_size","bigpatch","precontext","empty","shift","postcontext","patch_toText","patch_fromText","textline","textPointer","patchHeader","m","sign","toString","coords1","coords2","Processor","Pipe","DiffContext","PatchContext","ReverseContext","trivial","nested","arrays","dates","texts","processor","pipe","append","collectChildrenDiffFilter","diffFilter","objectsDiffFilter","shouldHaveResult","collectChildrenPatchFilter","patchFilter","collectChildrenReverseFilter","reverseFilter","left","right","process","module","key","value","parts","exec","UTC","selfOptions","pipes","name","input","context","lastPipe","lastContext","nextPipe","nextAfterChildren","next","hasResult","result","filters","debug","index","filter","log","filterName","exiting","resultCheck","msg","prepend","list","names","after","params","call","before","clear","should","error","noResult","Context","isArray","setResult","exit","leftType","rightType","leftIsArray","rightIsArray","children","child","childName","_t","arraysHaveMatchByRef","array1","array2","len1","len2","val1","val2","matchItems","value1","value2","objectHash","matchByPosition","hash1","hash2","hashCache1","hashCache2","lcs","ARRAY_MOVE","arrayIndexOf","array","item","matchContext","commonHead","commonTail","trimmed1","trimmed2","seq","get","removedItems","indices1","detectMove","includeValueOnMove","removedItemsLength","indexOnArray2","indices2","isMove","removeItemIndex1","compare","numerically","b","numericallyBy","toRemove","toInsert","toModify","sort","indexDiff","removedValue","toInsertLength","toModifyLength","modification","newName","substr","reverseArrayDeltaIndex","itemDelta","reverseIndex","deltaIndex","deltaItem","moveFromIndex","moveToIndex","deleteIndex","TEXT_DIFF","DEFAULT_MIN_LENGTH","cachedDiffPatch","getDiffMatchPatch","instance","dmpModuleName","err","diff_match_patch_not_found","txt1","txt2","textPatchFailed","minLength","textDiff","textDeltaReverse","l","lines","lineTmp","lineHeader","lineAdd","lineRemove","header","headerRegex","switchTo","parent","root","defaultMatch","lengthMatrix","matrix","backtrack","sequence","subsequence"],"mappings":"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","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o} */\ndiff_match_patch.Diff;\n\n\n/**\n * Find the differences between two texts. Simplifies the problem by stripping\n * any common prefix or suffix off the texts before diffing.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {boolean=} 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 {number} 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.} Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines,\n opt_deadline) {\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 var 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 [[DIFF_EQUAL, text1]];\n }\n return [];\n }\n\n if (typeof opt_checklines == 'undefined') {\n opt_checklines = true;\n }\n var checklines = opt_checklines;\n\n // Trim off common prefix (speedup).\n var commonlength = this.diff_commonPrefix(text1, text2);\n var commonprefix = text1.substring(0, commonlength);\n text1 = text1.substring(commonlength);\n text2 = text2.substring(commonlength);\n\n // Trim off common suffix (speedup).\n commonlength = this.diff_commonSuffix(text1, text2);\n var commonsuffix = text1.substring(text1.length - commonlength);\n text1 = text1.substring(0, text1.length - commonlength);\n text2 = text2.substring(0, text2.length - commonlength);\n\n // Compute the diff on the middle block.\n var diffs = this.diff_compute_(text1, text2, checklines, deadline);\n\n // Restore the prefix and suffix.\n if (commonprefix) {\n diffs.unshift([DIFF_EQUAL, commonprefix]);\n }\n if (commonsuffix) {\n diffs.push([DIFF_EQUAL, commonsuffix]);\n }\n 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 {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {boolean} 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 {number} deadline Time when the diff should be complete by.\n * @return {!Array.} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines,\n deadline) {\n var diffs;\n\n if (!text1) {\n // Just add some text (speedup).\n return [[DIFF_INSERT, text2]];\n }\n\n if (!text2) {\n // Just delete some text (speedup).\n return [[DIFF_DELETE, text1]];\n }\n\n var longtext = text1.length > text2.length ? text1 : text2;\n var shorttext = text1.length > text2.length ? text2 : text1;\n var i = longtext.indexOf(shorttext);\n if (i != -1) {\n // Shorter text is inside the longer text (speedup).\n diffs = [[DIFF_INSERT, longtext.substring(0, i)],\n [DIFF_EQUAL, shorttext],\n [DIFF_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] = DIFF_DELETE;\n }\n return diffs;\n }\n\n if (shorttext.length == 1) {\n // Single character string.\n // After the previous speedup, the character can't be an equality.\n return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n }\n longtext = shorttext = null; // Garbage collect.\n\n // Check to see if the problem can be split in two.\n var hm = this.diff_halfMatch_(text1, text2);\n if (hm) {\n // A half-match was found, sort out the return data.\n var text1_a = hm[0];\n var text1_b = hm[1];\n var text2_a = hm[2];\n var text2_b = hm[3];\n var mid_common = hm[4];\n // Send both pairs off for separate processing.\n var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);\n var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);\n // Merge the results.\n return diffs_a.concat([[DIFF_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 {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} deadline Time when the diff should be complete by.\n * @return {!Array.} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) {\n // Scan the text on a line-by-line basis first.\n var a = this.diff_linesToChars_(text1, text2);\n text1 = /** @type {string} */(a[0]);\n text2 = /** @type {string} */(a[1]);\n var linearray = /** @type {!Array.} */(a[2]);\n\n var diffs = this.diff_bisect_(text1, text2, 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([DIFF_EQUAL, '']);\n var pointer = 0;\n var count_delete = 0;\n var count_insert = 0;\n var text_delete = '';\n var text_insert = '';\n while (pointer < diffs.length) {\n switch (diffs[pointer][0]) {\n case DIFF_INSERT:\n count_insert++;\n text_insert += diffs[pointer][1];\n break;\n case DIFF_DELETE:\n count_delete++;\n text_delete += diffs[pointer][1];\n break;\n case DIFF_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 var a = this.diff_main(text_delete, text_insert, false, deadline);\n diffs.splice(pointer - count_delete - count_insert,\n count_delete + count_insert);\n pointer = pointer - count_delete - count_insert;\n for (var j = a.length - 1; j >= 0; j--) {\n diffs.splice(pointer, 0, a[j]);\n }\n pointer = pointer + a.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 Variations.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} deadline Time at which to bail if not yet complete.\n * @return {!Array.} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) {\n // Cache the text lengths to prevent multiple calls.\n var text1_length = text1.length;\n var text2_length = text2.length;\n var max_d = Math.ceil((text1_length + text2_length) / 2);\n var v_offset = max_d;\n var v_length = 2 * max_d;\n var v1 = new Array(v_length);\n var v2 = new Array(v_length);\n // Setting all elements to -1 is faster in Chrome & Firefox than mixing\n // integers and undefined.\n for (var x = 0; x < v_length; x++) {\n v1[x] = -1;\n v2[x] = -1;\n }\n v1[v_offset + 1] = 0;\n v2[v_offset + 1] = 0;\n var delta = text1_length - text2_length;\n // If the total number of characters is odd, then the front path will collide\n // with the reverse path.\n var front = (delta % 2 != 0);\n // Offsets for start and end of k loop.\n // Prevents mapping of space beyond the grid.\n var k1start = 0;\n var k1end = 0;\n var k2start = 0;\n var k2end = 0;\n for (var d = 0; d < max_d; d++) {\n // 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 (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\n var k1_offset = v_offset + k1;\n var x1;\n if (k1 == -d || k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1]) {\n x1 = v1[k1_offset + 1];\n } else {\n x1 = v1[k1_offset - 1] + 1;\n }\n var y1 = x1 - k1;\n while (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 var k2_offset = v_offset + delta - k1;\n if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {\n // Mirror x2 onto top-left coordinate system.\n var x2 = text1_length - v2[k2_offset];\n if (x1 >= x2) {\n // Overlap detected.\n return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);\n }\n }\n }\n }\n\n // Walk the reverse path one step.\n for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\n var k2_offset = v_offset + k2;\n var x2;\n if (k2 == -d || k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1]) {\n x2 = v2[k2_offset + 1];\n } else {\n x2 = v2[k2_offset - 1] + 1;\n }\n var y2 = x2 - k2;\n while (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 var k1_offset = v_offset + delta - k2;\n if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {\n var x1 = v1[k1_offset];\n var y1 = v_offset + x1 - k1_offset;\n // Mirror x2 onto top-left coordinate system.\n x2 = text1_length - x2;\n if (x1 >= x2) {\n // Overlap detected.\n return 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 [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n};\n\n\n/**\n * Given the location of the 'middle snake', split the diff in two parts\n * and recurse.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} x Index of split point in text1.\n * @param {number} y Index of split point in text2.\n * @param {number} deadline Time at which to bail if not yet complete.\n * @return {!Array.} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y,\n deadline) {\n var text1a = text1.substring(0, x);\n var text2a = text2.substring(0, y);\n var text1b = text1.substring(x);\n var text2b = text2.substring(y);\n\n // Compute both diffs serially.\n var diffs = this.diff_main(text1a, text2a, false, deadline);\n var 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 {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {!Array.>} Three element Array, containing the\n * encoded text1, the encoded text2 and the array of unique strings. The\n * zeroth element of the array of unique strings is intentionally blank.\n * @private\n */\ndiff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {\n var lineArray = []; // e.g. lineArray[4] == 'Hello\\n'\n var lineHash = {}; // e.g. lineHash['Hello\\n'] == 4\n\n // '\\x00' is a valid character, but various 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 * 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 {string} text String to encode.\n * @return {string} Encoded string.\n * @private\n */\n function diff_linesToCharsMunge_(text) {\n var 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 var lineStart = 0;\n var lineEnd = -1;\n // Keeping our own length variable is faster than looking it up.\n var 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 var 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 var chars1 = diff_linesToCharsMunge_(text1);\n var chars2 = diff_linesToCharsMunge_(text2);\n return [chars1, chars2, lineArray];\n};\n\n\n/**\n * Rehydrate the text in a diff from a string of line hashes to real lines of\n * text.\n * @param {!Array.} diffs Array of diff tuples.\n * @param {!Array.} lineArray Array of unique strings.\n * @private\n */\ndiff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) {\n for (var x = 0; x < diffs.length; x++) {\n var chars = diffs[x][1];\n var text = [];\n for (var 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 {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the start of each\n * string.\n */\ndiff_match_patch.prototype.diff_commonPrefix = function(text1, text2) {\n // Quick check for common null cases.\n if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {\n return 0;\n }\n // Binary search.\n // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n var pointermin = 0;\n var pointermax = Math.min(text1.length, text2.length);\n var pointermid = pointermax;\n var pointerstart = 0;\n while (pointermin < pointermid) {\n if (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 {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of each string.\n */\ndiff_match_patch.prototype.diff_commonSuffix = function(text1, text2) {\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 var pointermin = 0;\n var pointermax = Math.min(text1.length, text2.length);\n var pointermid = pointermax;\n var pointerend = 0;\n while (pointermin < pointermid) {\n if (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 {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of the first\n * string and the start of the second string.\n * @private\n */\ndiff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) {\n // Cache the text lengths to prevent multiple calls.\n var text1_length = text1.length;\n var text2_length = text2.length;\n // Eliminate the null case.\n if (text1_length == 0 || text2_length == 0) {\n return 0;\n }\n // Truncate the longer string.\n if (text1_length > text2_length) {\n text1 = text1.substring(text1_length - text2_length);\n } else if (text1_length < text2_length) {\n text2 = text2.substring(0, text1_length);\n }\n var text_length = Math.min(text1_length, text2_length);\n // Quick check for the worst case.\n if (text1 == text2) {\n return text_length;\n }\n\n // Start by looking for a single character match\n // and increase length until no match is found.\n // Performance analysis: http://neil.fraser.name/news/2010/11/04/\n var best = 0;\n var length = 1;\n while (true) {\n var pattern = text1.substring(text_length - length);\n var found = text2.indexOf(pattern);\n if (found == -1) {\n return best;\n }\n length += found;\n if (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 {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {Array.} 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 * @private\n */\ndiff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) {\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 var longtext = text1.length > text2.length ? text1 : text2;\n var shorttext = text1.length > text2.length ? text2 : text1;\n if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {\n return null; // Pointless.\n }\n var dmp = this; // 'this' becomes 'window' in a closure.\n\n /**\n * Does a substring of shorttext exist within longtext such that the substring\n * is at least half the length of longtext?\n * Closure, but does not reference any external variables.\n * @param {string} longtext Longer string.\n * @param {string} shorttext Shorter string.\n * @param {number} i Start index of quarter length substring within longtext.\n * @return {Array.} Five element Array, containing the prefix of\n * longtext, the suffix of longtext, the prefix of shorttext, the suffix\n * of shorttext and the common middle. Or null if there was no match.\n * @private\n */\n function diff_halfMatchI_(longtext, shorttext, i) {\n // Start with a 1/4 length substring at position i as a seed.\n var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\n var j = -1;\n var best_common = '';\n var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\n while ((j = shorttext.indexOf(seed, j + 1)) != -1) {\n var prefixLength = dmp.diff_commonPrefix(longtext.substring(i),\n shorttext.substring(j));\n var 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 // First check if the second quarter is the seed for a half-match.\n var hm1 = diff_halfMatchI_(longtext, shorttext,\n Math.ceil(longtext.length / 4));\n // Check again based on the third quarter.\n var hm2 = diff_halfMatchI_(longtext, shorttext,\n Math.ceil(longtext.length / 2));\n var hm;\n if (!hm1 && !hm2) {\n return null;\n } else if (!hm2) {\n hm = hm1;\n } else if (!hm1) {\n hm = hm2;\n } else {\n // Both matched. Select the longest.\n hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\n }\n\n // A half-match was found, sort out the return data.\n var text1_a, text1_b, text2_a, text2_b;\n if (text1.length > text2.length) {\n text1_a = hm[0];\n text1_b = hm[1];\n text2_a = hm[2];\n text2_b = hm[3];\n } else {\n text2_a = hm[0];\n text2_b = hm[1];\n text1_a = hm[2];\n text1_b = hm[3];\n }\n var mid_common = hm[4];\n return [text1_a, text1_b, text2_a, text2_b, mid_common];\n};\n\n\n/**\n * Reduce the number of edits by eliminating semantically trivial equalities.\n * @param {!Array.} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupSemantic = function(diffs) {\n var changes = false;\n var equalities = []; // Stack of indices where equalities are found.\n var equalitiesLength = 0; // Keeping our own length var is faster in JS.\n /** @type {?string} */\n var lastequality = null; // Always equal to equalities[equalitiesLength-1][1]\n var pointer = 0; // Index of current position.\n // Number of characters that changed prior to the equality.\n var length_insertions1 = 0;\n var length_deletions1 = 0;\n // Number of characters that changed after the equality.\n var length_insertions2 = 0;\n var length_deletions2 = 0;\n while (pointer < diffs.length) {\n if (diffs[pointer][0] == DIFF_EQUAL) { // 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 = /** @type {string} */(diffs[pointer][1]);\n } else { // An insertion or deletion.\n if (diffs[pointer][0] == DIFF_INSERT) {\n length_insertions2 += diffs[pointer][1].length;\n } else {\n length_deletions2 += diffs[pointer][1].length;\n }\n // Eliminate an equality that is smaller or equal to the edits on both\n // sides of it.\n if (lastequality !== null && (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 [DIFF_DELETE, lastequality]);\n // Change second copy to insert.\n diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n // Throw away the equality we just deleted.\n equalitiesLength--;\n // Throw away the previous equality (it needs to be reevaluated).\n equalitiesLength--;\n pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\n length_insertions1 = 0; // Reset the counters.\n length_deletions1 = 0;\n length_insertions2 = 0;\n length_deletions2 = 0;\n lastequality = null;\n changes = true;\n }\n }\n pointer++;\n }\n\n // Normalize the diff.\n if (changes) {\n this.diff_cleanupMerge(diffs);\n }\n this.diff_cleanupSemanticLossless(diffs);\n\n // Find any overlaps between deletions and insertions.\n // e.g: abcxxxxxxdef\n // -> abcxxxdef\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] == DIFF_DELETE &&\n diffs[pointer][0] == DIFF_INSERT) {\n var deletion = /** @type {string} */(diffs[pointer - 1][1]);\n var insertion = /** @type {string} */(diffs[pointer][1]);\n var overlap_length = this.diff_commonOverlap_(deletion, insertion);\n if (overlap_length >= deletion.length / 2 ||\n overlap_length >= insertion.length / 2) {\n // Overlap found. Insert an equality and trim the surrounding edits.\n diffs.splice(pointer, 0,\n [DIFF_EQUAL, insertion.substring(0, overlap_length)]);\n diffs[pointer - 1][1] =\n deletion.substring(0, deletion.length - overlap_length);\n diffs[pointer + 1][1] = insertion.substring(overlap_length);\n pointer++;\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 cat came. -> The cat came.\n * @param {!Array.} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {\n // Define some regex patterns for matching boundaries.\n var punctuation = /[^a-zA-Z0-9]/;\n var whitespace = /\\s/;\n var linebreak = /[\\r\\n]/;\n var blanklineEnd = /\\n\\r?\\n$/;\n var blanklineStart = /^\\r?\\n\\r?\\n/;\n\n /**\n * Given two strings, compute a score representing whether the internal\n * boundary falls on logical boundaries.\n * Scores range from 5 (best) to 0 (worst).\n * Closure, makes reference to regex patterns defined above.\n * @param {string} one First string.\n * @param {string} two Second string.\n * @return {number} The score.\n * @private\n */\n function diff_cleanupSemanticScore_(one, two) {\n if (!one || !two) {\n // Edges are the best.\n return 5;\n }\n\n // Each port of this function behaves slightly differently due to\n // subtle differences in each language's definition of things like\n // 'whitespace'. Since this function's purpose is largely cosmetic,\n // the choice has been made to use each language's native features\n // rather than force total conformity.\n var score = 0;\n // One point for non-alphanumeric.\n if (one.charAt(one.length - 1).match(punctuation) ||\n two.charAt(0).match(punctuation)) {\n score++;\n // Two points for whitespace.\n if (one.charAt(one.length - 1).match(whitespace) ||\n two.charAt(0).match(whitespace)) {\n score++;\n // Three points for line breaks.\n if (one.charAt(one.length - 1).match(linebreak) ||\n two.charAt(0).match(linebreak)) {\n score++;\n // Four points for blank lines.\n if (one.match(blanklineEnd) || two.match(blanklineStart)) {\n score++;\n }\n }\n }\n }\n return score;\n }\n\n var pointer = 1;\n // Intentionally ignore the first and last element (don't need checking).\n while (pointer < diffs.length - 1) {\n if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n diffs[pointer + 1][0] == DIFF_EQUAL) {\n // This is a single edit surrounded by equalities.\n var equality1 = /** @type {string} */(diffs[pointer - 1][1]);\n var edit = /** @type {string} */(diffs[pointer][1]);\n var equality2 = /** @type {string} */(diffs[pointer + 1][1]);\n\n // First, shift the edit as far left as possible.\n var commonOffset = this.diff_commonSuffix(equality1, edit);\n if (commonOffset) {\n var commonString = edit.substring(edit.length - commonOffset);\n equality1 = equality1.substring(0, equality1.length - commonOffset);\n edit = commonString + edit.substring(0, edit.length - commonOffset);\n equality2 = commonString + equality2;\n }\n\n // Second, step character by character right, looking for the best fit.\n var bestEquality1 = equality1;\n var bestEdit = edit;\n var bestEquality2 = equality2;\n var bestScore = diff_cleanupSemanticScore_(equality1, edit) +\n diff_cleanupSemanticScore_(edit, equality2);\n while (edit.charAt(0) === equality2.charAt(0)) {\n equality1 += edit.charAt(0);\n edit = edit.substring(1) + equality2.charAt(0);\n equality2 = equality2.substring(1);\n var score = 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 {!Array.} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) {\n var changes = false;\n var equalities = []; // Stack of indices where equalities are found.\n var equalitiesLength = 0; // Keeping our own length var is faster in JS.\n var lastequality = ''; // Always equal to equalities[equalitiesLength-1][1]\n var pointer = 0; // Index of current position.\n // Is there an insertion operation before the last equality.\n var pre_ins = false;\n // Is there a deletion operation before the last equality.\n var pre_del = false;\n // Is there an insertion operation after the last equality.\n var post_ins = false;\n // Is there a deletion operation after the last equality.\n var post_del = false;\n while (pointer < diffs.length) {\n if (diffs[pointer][0] == DIFF_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 = '';\n }\n post_ins = post_del = false;\n } else { // An insertion or deletion.\n if (diffs[pointer][0] == DIFF_DELETE) {\n post_del = true;\n } else {\n post_ins = true;\n }\n /*\n * Five types to be split:\n * ABXYCD\n * AXCD\n * ABXC\n * AXCD\n * ABXC\n */\n if (lastequality && ((pre_ins && pre_del && post_ins && post_del) ||\n ((lastequality.length < this.Diff_EditCost / 2) &&\n (pre_ins + pre_del + post_ins + post_del) == 3))) {\n // Duplicate record.\n diffs.splice(equalities[equalitiesLength - 1], 0,\n [DIFF_DELETE, lastequality]);\n // Change second copy to insert.\n diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n equalitiesLength--; // Throw away the equality we just deleted;\n lastequality = '';\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 {!Array.} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupMerge = function(diffs) {\n diffs.push([DIFF_EQUAL, '']); // Add a dummy entry at the end.\n var pointer = 0;\n var count_delete = 0;\n var count_insert = 0;\n var text_delete = '';\n var text_insert = '';\n var commonlength;\n while (pointer < diffs.length) {\n switch (diffs[pointer][0]) {\n case DIFF_INSERT:\n count_insert++;\n text_insert += diffs[pointer][1];\n pointer++;\n break;\n case DIFF_DELETE:\n count_delete++;\n text_delete += diffs[pointer][1];\n pointer++;\n break;\n case DIFF_EQUAL:\n // 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 DIFF_EQUAL) {\n diffs[pointer - count_delete - count_insert - 1][1] +=\n text_insert.substring(0, commonlength);\n } else {\n diffs.splice(0, 0, [DIFF_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_delete - count_insert,\n count_delete + count_insert, [DIFF_INSERT, text_insert]);\n } else if (count_insert === 0) {\n diffs.splice(pointer - count_delete - count_insert,\n count_delete + count_insert, [DIFF_DELETE, text_delete]);\n } else {\n diffs.splice(pointer - count_delete - count_insert,\n count_delete + count_insert, [DIFF_DELETE, text_delete],\n [DIFF_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] == DIFF_EQUAL) {\n // Merge this equality with the previous one.\n diffs[pointer - 1][1] += diffs[pointer][1];\n diffs.splice(pointer, 1);\n } else {\n pointer++;\n }\n count_insert = 0;\n count_delete = 0;\n text_delete = '';\n text_insert = '';\n break;\n }\n }\n if (diffs[diffs.length - 1][1] === '') {\n diffs.pop(); // Remove the dummy entry at the end.\n }\n\n // Second pass: look for single edits surrounded on both sides by equalities\n // which can be shifted sideways to eliminate an equality.\n // e.g: ABAC -> ABAC\n var changes = false;\n pointer = 1;\n // Intentionally ignore the first and last element (don't need checking).\n while (pointer < diffs.length - 1) {\n if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n diffs[pointer + 1][0] == DIFF_EQUAL) {\n // This is a single edit surrounded by equalities.\n if (diffs[pointer][1].substring(diffs[pointer][1].length -\n diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {\n // Shift the edit over the previous equality.\n diffs[pointer][1] = diffs[pointer - 1][1] +\n diffs[pointer][1].substring(0, diffs[pointer][1].length -\n diffs[pointer - 1][1].length);\n diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n diffs.splice(pointer - 1, 1);\n changes = true;\n } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n diffs[pointer + 1][1]) {\n // Shift the edit over the next equality.\n diffs[pointer - 1][1] += diffs[pointer + 1][1];\n diffs[pointer][1] =\n diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\n diffs[pointer + 1][1];\n diffs.splice(pointer + 1, 1);\n changes = true;\n }\n }\n pointer++;\n }\n // If shifts were made, the diff needs reordering and another shift sweep.\n if (changes) {\n 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 {!Array.} diffs Array of diff tuples.\n * @param {number} loc Location within text1.\n * @return {number} Location within text2.\n */\ndiff_match_patch.prototype.diff_xIndex = function(diffs, loc) {\n var chars1 = 0;\n var chars2 = 0;\n var last_chars1 = 0;\n var last_chars2 = 0;\n var x;\n for (x = 0; x < diffs.length; x++) {\n if (diffs[x][0] !== DIFF_INSERT) { // Equality or deletion.\n chars1 += diffs[x][1].length;\n }\n if (diffs[x][0] !== DIFF_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] === DIFF_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 {!Array.} diffs Array of diff tuples.\n * @return {string} HTML representation.\n */\ndiff_match_patch.prototype.diff_prettyHtml = function(diffs) {\n var html = [];\n var i = 0;\n var pattern_amp = /&/g;\n var pattern_lt = //g;\n var pattern_para = /\\n/g;\n for (var x = 0; x < diffs.length; x++) {\n var op = diffs[x][0]; // Operation (insert, delete, equal)\n var data = diffs[x][1]; // Text of change.\n var text = data.replace(pattern_amp, '&').replace(pattern_lt, '<')\n .replace(pattern_gt, '>').replace(pattern_para, '¶
');\n switch (op) {\n case DIFF_INSERT:\n html[x] = '' + text + '';\n break;\n case DIFF_DELETE:\n html[x] = '' + text + '';\n break;\n case DIFF_EQUAL:\n html[x] = '' + text + '';\n break;\n }\n if (op !== DIFF_DELETE) {\n i += data.length;\n }\n }\n return html.join('');\n};\n\n\n/**\n * Compute and return the source text (all equalities and deletions).\n * @param {!Array.} diffs Array of diff tuples.\n * @return {string} Source text.\n */\ndiff_match_patch.prototype.diff_text1 = function(diffs) {\n var text = [];\n for (var x = 0; x < diffs.length; x++) {\n if (diffs[x][0] !== DIFF_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 {!Array.} diffs Array of diff tuples.\n * @return {string} Destination text.\n */\ndiff_match_patch.prototype.diff_text2 = function(diffs) {\n var text = [];\n for (var x = 0; x < diffs.length; x++) {\n if (diffs[x][0] !== DIFF_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 {!Array.} diffs Array of diff tuples.\n * @return {number} Number of changes.\n */\ndiff_match_patch.prototype.diff_levenshtein = function(diffs) {\n var levenshtein = 0;\n var insertions = 0;\n var deletions = 0;\n for (var x = 0; x < diffs.length; x++) {\n var op = diffs[x][0];\n var data = diffs[x][1];\n switch (op) {\n case DIFF_INSERT:\n insertions += data.length;\n break;\n case DIFF_DELETE:\n deletions += data.length;\n break;\n case DIFF_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 {!Array.} diffs Array of diff tuples.\n * @return {string} Delta text.\n */\ndiff_match_patch.prototype.diff_toDelta = function(diffs) {\n var text = [];\n for (var x = 0; x < diffs.length; x++) {\n switch (diffs[x][0]) {\n case DIFF_INSERT:\n text[x] = '+' + encodeURI(diffs[x][1]);\n break;\n case DIFF_DELETE:\n text[x] = '-' + diffs[x][1].length;\n break;\n case DIFF_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 {string} text1 Source string for the diff.\n * @param {string} delta Delta text.\n * @return {!Array.} Array of diff tuples.\n * @throws {!Error} If invalid input.\n */\ndiff_match_patch.prototype.diff_fromDelta = function(text1, delta) {\n var diffs = [];\n var diffsLength = 0; // Keeping our own length var is faster in JS.\n var pointer = 0; // Cursor in text1\n var tokens = delta.split(/\\t/g);\n for (var 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 var param = tokens[x].substring(1);\n switch (tokens[x].charAt(0)) {\n case '+':\n try {\n diffs[diffsLength++] = [DIFF_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 var n = parseInt(param, 10);\n if (isNaN(n) || n < 0) {\n throw new Error('Invalid number in diff_fromDelta: ' + param);\n }\n var text = text1.substring(pointer, pointer += n);\n if (tokens[x].charAt(0) == '=') {\n diffs[diffsLength++] = [DIFF_EQUAL, text];\n } else {\n diffs[diffsLength++] = [DIFF_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// MATCH FUNCTIONS\n\n\n/**\n * Locate the best instance of 'pattern' in 'text' near 'loc'.\n * @param {string} text The text to search.\n * @param {string} pattern The pattern to search for.\n * @param {number} loc The location to search around.\n * @return {number} Best match index or -1.\n */\ndiff_match_patch.prototype.match_main = function(text, pattern, loc) {\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 {string} text The text to search.\n * @param {string} pattern The pattern to search for.\n * @param {number} loc The location to search around.\n * @return {number} Best match index or -1.\n * @private\n */\ndiff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) {\n if (pattern.length > this.Match_MaxBits) {\n throw new Error('Pattern too long for this browser.');\n }\n\n // Initialise the alphabet.\n var s = this.match_alphabet_(pattern);\n\n var 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 {number} e Number of errors in match.\n * @param {number} x Location of match.\n * @return {number} Overall score for match (0.0 = good, 1.0 = bad).\n * @private\n */\n function match_bitapScore_(e, x) {\n var accuracy = e / pattern.length;\n var 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 var score_threshold = this.Match_Threshold;\n // Is there a nearby exact match? (speedup)\n var 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 var matchmask = 1 << (pattern.length - 1);\n best_loc = -1;\n\n var bin_min, bin_mid;\n var bin_max = pattern.length + text.length;\n var last_rd;\n for (var 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 var start = Math.max(1, loc - bin_mid + 1);\n var finish = Math.min(loc + bin_mid, text.length) + pattern.length;\n\n var rd = Array(finish + 2);\n rd[finish + 1] = (1 << d) - 1;\n for (var j = finish; j >= start; j--) {\n // The alphabet (s) is a sparse hash, so the following line generates\n // warnings.\n var 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 var 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 {string} pattern The text to encode.\n * @return {!Object} Hash of character locations.\n * @private\n */\ndiff_match_patch.prototype.match_alphabet_ = function(pattern) {\n var s = {};\n for (var i = 0; i < pattern.length; i++) {\n s[pattern.charAt(i)] = 0;\n }\n for (var i = 0; i < pattern.length; i++) {\n s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);\n }\n return s;\n};\n\n\n// PATCH FUNCTIONS\n\n\n/**\n * Increase the context until it is unique,\n * but don't let the pattern expand beyond Match_MaxBits.\n * @param {!diff_match_patch.patch_obj} patch The patch to grow.\n * @param {string} text Source text.\n * @private\n */\ndiff_match_patch.prototype.patch_addContext_ = function(patch, text) {\n if (text.length == 0) {\n return;\n }\n var pattern = text.substring(patch.start2, patch.start2 + patch.length1);\n var 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 var prefix = text.substring(patch.start2 - padding, patch.start2);\n if (prefix) {\n patch.diffs.unshift([DIFF_EQUAL, prefix]);\n }\n // Add the suffix.\n var suffix = text.substring(patch.start2 + patch.length1,\n patch.start2 + patch.length1 + padding);\n if (suffix) {\n patch.diffs.push([DIFF_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 {string|!Array.} a text1 (methods 1,3,4) or\n * Array of diff tuples for text1 to text2 (method 2).\n * @param {string|!Array.} opt_b text2 (methods 1,4) or\n * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).\n * @param {string|!Array.} opt_c Array of diff tuples\n * for text1 to text2 (method 4) or undefined (methods 1,2,3).\n * @return {!Array.} Array of patch objects.\n */\ndiff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) {\n var 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 = /** @type {string} */(a);\n diffs = this.diff_main(text1, /** @type {string} */(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 = /** @type {!Array.} */(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 = /** @type {string} */(a);\n diffs = /** @type {!Array.} */(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 = /** @type {string} */(a);\n diffs = /** @type {!Array.} */(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 var patches = [];\n var patch = new diff_match_patch.patch_obj();\n var patchDiffLength = 0; // Keeping our own length var is faster in JS.\n var char_count1 = 0; // Number of characters into the text1 string.\n var 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 var prepatch_text = text1;\n var postpatch_text = text1;\n for (var x = 0; x < diffs.length; x++) {\n var diff_type = diffs[x][0];\n var diff_text = diffs[x][1];\n\n if (!patchDiffLength && diff_type !== DIFF_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 DIFF_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 DIFF_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 DIFF_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 diff_match_patch.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 !== DIFF_INSERT) {\n char_count1 += diff_text.length;\n }\n if (diff_type !== DIFF_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 {!Array.} patches Array of patch objects.\n * @return {!Array.} Array of patch objects.\n */\ndiff_match_patch.prototype.patch_deepCopy = function(patches) {\n // Making deep copies is hard in JavaScript.\n var patchesCopy = [];\n for (var x = 0; x < patches.length; x++) {\n var patch = patches[x];\n var patchCopy = new diff_match_patch.patch_obj();\n patchCopy.diffs = [];\n for (var y = 0; y < patch.diffs.length; y++) {\n patchCopy.diffs[y] = patch.diffs[y].slice();\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 {!Array.} patches Array of patch objects.\n * @param {string} text Old text.\n * @return {!Array.>} Two element Array, containing the\n * new text and an array of boolean values.\n */\ndiff_match_patch.prototype.patch_apply = function(patches, text) {\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 var 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 var delta = 0;\n var results = [];\n for (var x = 0; x < patches.length; x++) {\n var expected_loc = patches[x].start2 + delta;\n var text1 = this.diff_text1(patches[x].diffs);\n var start_loc;\n var 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 var 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 var 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 var index1 = 0;\n var index2;\n for (var y = 0; y < patches[x].diffs.length; y++) {\n var mod = patches[x].diffs[y];\n if (mod[0] !== DIFF_EQUAL) {\n index2 = this.diff_xIndex(diffs, index1);\n }\n if (mod[0] === DIFF_INSERT) { // Insertion\n text = text.substring(0, start_loc + index2) + mod[1] +\n text.substring(start_loc + index2);\n } else if (mod[0] === DIFF_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] !== DIFF_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 {!Array.} patches Array of patch objects.\n * @return {string} The padding string added to each side.\n */\ndiff_match_patch.prototype.patch_addPadding = function(patches) {\n var paddingLength = this.Patch_Margin;\n var nullPadding = '';\n for (var x = 1; x <= paddingLength; x++) {\n nullPadding += String.fromCharCode(x);\n }\n\n // Bump all the patches forward.\n for (var 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 var patch = patches[0];\n var diffs = patch.diffs;\n if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {\n // Add nullPadding equality.\n diffs.unshift([DIFF_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 var 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] != DIFF_EQUAL) {\n // Add nullPadding equality.\n diffs.push([DIFF_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 var 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 {!Array.} patches Array of patch objects.\n */\ndiff_match_patch.prototype.patch_splitMax = function(patches) {\n var patch_size = this.Match_MaxBits;\n for (var x = 0; x < patches.length; x++) {\n if (patches[x].length1 > patch_size) {\n var bigpatch = patches[x];\n // Remove the big old patch.\n patches.splice(x--, 1);\n var start1 = bigpatch.start1;\n var start2 = bigpatch.start2;\n var precontext = '';\n while (bigpatch.diffs.length !== 0) {\n // Create one of several smaller patches.\n var patch = new diff_match_patch.patch_obj();\n var 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([DIFF_EQUAL, precontext]);\n }\n while (bigpatch.diffs.length !== 0 &&\n patch.length1 < patch_size - this.Patch_Margin) {\n var diff_type = bigpatch.diffs[0][0];\n var diff_text = bigpatch.diffs[0][1];\n if (diff_type === DIFF_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 === DIFF_DELETE && patch.diffs.length == 1 &&\n patch.diffs[0][0] == DIFF_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 === DIFF_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 var 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] === DIFF_EQUAL) {\n patch.diffs[patch.diffs.length - 1][1] += postcontext;\n } else {\n patch.diffs.push([DIFF_EQUAL, postcontext]);\n }\n }\n if (!empty) {\n patches.splice(++x, 0, patch);\n }\n }\n }\n }\n};\n\n\n/**\n * Take a list of patches and return a textual representation.\n * @param {!Array.} patches Array of patch objects.\n * @return {string} Text representation of patches.\n */\ndiff_match_patch.prototype.patch_toText = function(patches) {\n var text = [];\n for (var 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 {string} textline Text representation of patches.\n * @return {!Array.} Array of patch objects.\n * @throws {!Error} If invalid input.\n */\ndiff_match_patch.prototype.patch_fromText = function(textline) {\n var patches = [];\n if (!textline) {\n return patches;\n }\n var text = textline.split('\\n');\n var textPointer = 0;\n var patchHeader = /^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$/;\n while (textPointer < text.length) {\n var m = text[textPointer].match(patchHeader);\n if (!m) {\n throw new Error('Invalid patch string: ' + text[textPointer]);\n }\n var patch = new diff_match_patch.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 var sign = text[textPointer].charAt(0);\n try {\n var 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([DIFF_DELETE, line]);\n } else if (sign == '+') {\n // Insertion.\n patch.diffs.push([DIFF_INSERT, line]);\n } else if (sign == ' ') {\n // Minor equality.\n patch.diffs.push([DIFF_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 * Class representing one patch operation.\n * @constructor\n */\ndiff_match_patch.patch_obj = function() {\n /** @type {!Array.} */\n this.diffs = [];\n /** @type {?number} */\n this.start1 = null;\n /** @type {?number} */\n this.start2 = null;\n /** @type {number} */\n this.length1 = 0;\n /** @type {number} */\n this.length2 = 0;\n};\n\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 * @return {string} The GNU diff string.\n */\ndiff_match_patch.patch_obj.prototype.toString = function() {\n var 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 var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\\n'];\n var op;\n // Escape the body of the patch with %xx notation.\n for (var x = 0; x < this.diffs.length; x++) {\n switch (this.diffs[x][0]) {\n case DIFF_INSERT:\n op = '+';\n break;\n case DIFF_DELETE:\n op = '-';\n break;\n case DIFF_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\n// Export these global variables so that they survive Google's JS compiler.\n// In a browser, 'this' will be 'window'.\n// In node.js 'this' will be a global object.\nthis['diff_match_patch'] = diff_match_patch;\nthis['DIFF_DELETE'] = DIFF_DELETE;\nthis['DIFF_INSERT'] = DIFF_INSERT;\nthis['DIFF_EQUAL'] = DIFF_EQUAL;\n\n","var Processor = require('./processor').Processor;\nvar Pipe = require('./pipe').Pipe;\nvar DiffContext = require('./contexts/diff').DiffContext;\nvar PatchContext = require('./contexts/patch').PatchContext;\nvar ReverseContext = require('./contexts/reverse').ReverseContext;\n\nvar trivial = require('./filters/trivial');\nvar nested = require('./filters/nested');\nvar arrays = require('./filters/arrays');\nvar dates = require('./filters/dates');\nvar texts = require('./filters/texts');\n\nvar DiffPatcher = function DiffPatcher(options) {\n this.processor = new Processor(options);\n this.processor.pipe(new Pipe('diff').append(\n nested.collectChildrenDiffFilter,\n trivial.diffFilter,\n dates.diffFilter,\n texts.diffFilter,\n nested.objectsDiffFilter,\n arrays.diffFilter\n ).shouldHaveResult());\n this.processor.pipe(new Pipe('patch').append(\n nested.collectChildrenPatchFilter,\n arrays.collectChildrenPatchFilter,\n trivial.patchFilter,\n texts.patchFilter,\n nested.patchFilter,\n arrays.patchFilter\n ).shouldHaveResult());\n this.processor.pipe(new Pipe('reverse').append(\n nested.collectChildrenReverseFilter,\n arrays.collectChildrenReverseFilter,\n trivial.reverseFilter,\n texts.reverseFilter,\n nested.reverseFilter,\n arrays.reverseFilter\n ).shouldHaveResult());\n};\n\nDiffPatcher.prototype.options = function() {\n return this.processor.options.apply(this.processor, arguments);\n};\n\nDiffPatcher.prototype.diff = function(left, right) {\n return this.processor.process(new DiffContext(left, right));\n};\n\nDiffPatcher.prototype.patch = function(left, delta) {\n return this.processor.process(new PatchContext(left, delta));\n};\n\nDiffPatcher.prototype.reverse = function(delta) {\n return this.processor.process(new ReverseContext(delta));\n};\n\nDiffPatcher.prototype.unpatch = function(right, delta) {\n return this.patch(right, this.reverse(delta));\n};\n\nexports.DiffPatcher = DiffPatcher;\n","// use as 2nd parameter for JSON.parse to revive Date instances\nmodule.exports = function dateReviver(key, value) {\n var parts;\n if (typeof value === 'string') {\n parts = /^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(?:\\.(\\d*))?(Z|([+\\-])(\\d{2}):(\\d{2}))$/.exec(value);\n if (parts) {\n return new Date(Date.UTC(+parts[1], +parts[2] - 1, +parts[3], +parts[4], +parts[5], +parts[6], +(parts[7] || 0)));\n }\n }\n return value;\n};\n","\nvar Processor = function Processor(options){\n\tthis.selfOptions = options;\n\tthis.pipes = {};\n};\n\nProcessor.prototype.options = function(options) {\n\tif (options) {\n\t\tthis.selfOptions = options;\n\t}\n\treturn this.selfOptions;\n};\n\nProcessor.prototype.pipe = function(name, pipe) {\n\tif (typeof name === 'string') {\n\t\tif (typeof pipe === 'undefined') {\n\t\t\treturn this.pipes[name];\n\t\t} else {\n\t\t\tthis.pipes[name] = pipe;\n\t\t}\n\t}\n\tif (name && name.name) {\n\t\tpipe = name;\n\t\tif (pipe.processor === this) { return pipe; }\n\t\tthis.pipes[pipe.name] = pipe;\n\t}\n\tpipe.processor = this;\n\treturn pipe;\n};\n\nProcessor.prototype.process = function(input, pipe) {\n\tvar context = input;\n\tcontext.options = this.options();\n\tvar nextPipe = pipe || input.pipe || 'default';\n\tvar lastPipe, lastContext;\n\twhile (nextPipe) {\n\t\tif (typeof context.nextAfterChildren !== 'undefined') {\n\t\t\t// children processed and coming back to parent\n\t\t\tcontext.next = context.nextAfterChildren;\n\t\t\tcontext.nextAfterChildren = null;\n\t\t}\n\n\t\tif (typeof nextPipe === 'string') {\n\t\t\tnextPipe = this.pipe(nextPipe);\n\t\t}\n\t\tnextPipe.process(context);\n\t\tlastContext = context;\n\t\tlastPipe = nextPipe;\n\t\tnextPipe = null;\n\t\tif (context) {\n\t\t\tif (context.next) {\n\t\t\t\tcontext = context.next;\n\t\t\t\tnextPipe = lastContext.nextPipe || context.pipe || lastPipe;\n\t\t\t}\n\t\t}\n\t}\n\treturn context.hasResult ? context.result : undefined;\n};\n\nexports.Processor = Processor;\n","var Pipe = function Pipe(name) {\n this.name = name;\n this.filters = [];\n};\n\nPipe.prototype.process = function(input) {\n if (!this.processor) {\n throw new Error('add this pipe to a processor before using it');\n }\n var debug = this.debug;\n var length = this.filters.length;\n var context = input;\n for (var index = 0; index < length; index++) {\n var filter = this.filters[index];\n if (debug) {\n this.log('filter: ' + filter.filterName);\n }\n filter(context);\n if (typeof context === 'object' && context.exiting) {\n context.exiting = false;\n break;\n }\n }\n if (!context.next && this.resultCheck) {\n this.resultCheck(context);\n }\n};\n\nPipe.prototype.log = function(msg) {\n console.log('[jsondiffpatch] ' + this.name + ' pipe, ' + msg);\n};\n\nPipe.prototype.append = function() {\n this.filters.push.apply(this.filters, arguments);\n return this;\n};\n\nPipe.prototype.prepend = function() {\n this.filters.unshift.apply(this.filters, arguments);\n return this;\n};\n\nPipe.prototype.indexOf = function(filterName) {\n if (!filterName) {\n throw new Error('a filter name is required');\n }\n for (var index = 0; index < this.filters.length; index++) {\n var filter = this.filters[index];\n if (filter.filterName === filterName) {\n return index;\n }\n }\n throw new Error('filter not found: ' + filterName);\n};\n\nPipe.prototype.list = function() {\n var names = [];\n for (var index = 0; index < this.filters.length; index++) {\n var filter = this.filters[index];\n names.push(filter.filterName);\n }\n return names;\n};\n\nPipe.prototype.after = function(filterName) {\n var index = this.indexOf(filterName);\n var params = Array.prototype.slice.call(arguments, 1);\n if (!params.length) {\n throw new Error('a filter is required');\n }\n params.unshift(index + 1, 0);\n Array.prototype.splice.apply(this.filters, params);\n return this;\n};\n\nPipe.prototype.before = function(filterName) {\n var index = this.indexOf(filterName);\n var params = Array.prototype.slice.call(arguments, 1);\n if (!params.length) {\n throw new Error('a filter is required');\n }\n params.unshift(index, 0);\n Array.prototype.splice.apply(this.filters, params);\n return this;\n};\n\nPipe.prototype.clear = function() {\n this.filters.length = 0;\n return this;\n};\n\nPipe.prototype.shouldHaveResult = function(should) {\n if (should === false) {\n this.resultCheck = null;\n return;\n }\n if (this.resultCheck) {\n return;\n }\n var pipe = this;\n this.resultCheck = function(context) {\n if (!context.hasResult) {\n console.log(context);\n var error = new Error(pipe.name + ' failed');\n error.noResult = true;\n throw error;\n }\n };\n return this;\n};\n\nexports.Pipe = Pipe;\n","var Context = require('./context').Context;\n\nvar DiffContext = function DiffContext(left, right) {\n this.left = left;\n this.right = right;\n this.pipe = 'diff';\n};\n\nDiffContext.prototype = new Context();\n\nexports.DiffContext = DiffContext;\n","var Context = require('./context').Context;\n\nvar ReverseContext = function ReverseContext(delta) {\n this.delta = delta;\n this.pipe = 'reverse';\n};\n\nReverseContext.prototype = new Context();\n\nexports.ReverseContext = ReverseContext;\n","var Context = require('./context').Context;\n\nvar PatchContext = function PatchContext(left, delta) {\n this.left = left;\n this.delta = delta;\n this.pipe = 'patch';\n};\n\nPatchContext.prototype = new Context();\n\nexports.PatchContext = PatchContext;\n","var isArray = (typeof Array.isArray === 'function') ?\n // use native function\n Array.isArray :\n // use instanceof operator\n function(a) {\n return a instanceof Array;\n };\n\nvar diffFilter = function trivialMatchesDiffFilter(context) {\n if (context.left === context.right) {\n context.setResult(undefined).exit();\n return;\n }\n if (typeof context.left === 'undefined') {\n if (typeof context.right === 'function') {\n throw new Error('functions are not supported');\n }\n context.setResult([context.right]).exit();\n return;\n }\n if (typeof context.right === 'undefined') {\n context.setResult([context.left, 0, 0]).exit();\n return;\n }\n if (typeof context.left === 'function' || typeof context.right === 'function') {\n throw new Error('functions are not supported');\n }\n context.leftType = context.left === null ? 'null' : typeof context.left;\n context.rightType = context.right === null ? 'null' : typeof context.right;\n if (context.leftType !== context.rightType) {\n context.setResult([context.left, context.right]).exit();\n return;\n }\n if (context.leftType === 'boolean' || context.leftType === 'number') {\n context.setResult([context.left, context.right]).exit();\n return;\n }\n if (context.leftType === 'object') {\n context.leftIsArray = isArray(context.left);\n }\n if (context.rightType === 'object') {\n context.rightIsArray = isArray(context.right);\n }\n if (context.leftIsArray !== context.rightIsArray) {\n context.setResult([context.left, context.right]).exit();\n return;\n }\n};\ndiffFilter.filterName = 'trivial';\n\nvar patchFilter = function trivialMatchesPatchFilter(context) {\n if (typeof context.delta === 'undefined') {\n context.setResult(context.left).exit();\n return;\n }\n context.nested = !isArray(context.delta);\n if (context.nested) {\n return;\n }\n if (context.delta.length === 1) {\n context.setResult(context.delta[0]).exit();\n return;\n }\n if (context.delta.length === 2) {\n context.setResult(context.delta[1]).exit();\n return;\n }\n if (context.delta.length === 3 && context.delta[2] === 0) {\n context.setResult(undefined).exit();\n return;\n }\n};\npatchFilter.filterName = 'trivial';\n\nvar reverseFilter = function trivialReferseFilter(context) {\n if (typeof context.delta === 'undefined') {\n context.setResult(context.delta).exit();\n return;\n }\n context.nested = !isArray(context.delta);\n if (context.nested) {\n return;\n }\n if (context.delta.length === 1) {\n context.setResult([context.delta[0], 0, 0]).exit();\n return;\n }\n if (context.delta.length === 2) {\n context.setResult([context.delta[1], context.delta[0]]).exit();\n return;\n }\n if (context.delta.length === 3 && context.delta[2] === 0) {\n context.setResult([context.delta[0]]).exit();\n return;\n }\n};\nreverseFilter.filterName = 'trivial';\n\nexports.diffFilter = diffFilter;\nexports.patchFilter = patchFilter;\nexports.reverseFilter = reverseFilter;\n","var DiffContext = require('../contexts/diff').DiffContext;\nvar PatchContext = require('../contexts/patch').PatchContext;\nvar ReverseContext = require('../contexts/reverse').ReverseContext;\n\nvar collectChildrenDiffFilter = function collectChildrenDiffFilter(context) {\n if (!context || !context.children) {\n return;\n }\n var length = context.children.length;\n var child;\n var result = context.result;\n for (var index = 0; index < length; index++) {\n child = context.children[index];\n if (typeof child.result === 'undefined') {\n continue;\n }\n result = result || {};\n result[child.childName] = child.result;\n }\n if (result && context.leftIsArray) {\n result._t = 'a';\n }\n context.setResult(result).exit();\n};\ncollectChildrenDiffFilter.filterName = 'collectChildren';\n\nvar objectsDiffFilter = function objectsDiffFilter(context) {\n if (context.leftIsArray || context.leftType !== 'object') {\n return;\n }\n\n var name, child;\n for (name in context.left) {\n child = new DiffContext(context.left[name], context.right[name]);\n context.push(child, name);\n }\n for (name in context.right) {\n if (typeof context.left[name] === 'undefined') {\n child = new DiffContext(undefined, context.right[name]);\n context.push(child, name);\n }\n }\n\n if (!context.children || context.children.length === 0) {\n context.setResult(undefined).exit();\n return;\n }\n context.exit();\n};\nobjectsDiffFilter.filterName = 'objects';\n\nvar patchFilter = function nestedPatchFilter(context) {\n if (!context.nested) {\n return;\n }\n if (context.delta._t) {\n return;\n }\n var name, child;\n for (name in context.delta) {\n child = new PatchContext(context.left[name], context.delta[name]);\n context.push(child, name);\n }\n context.exit();\n};\npatchFilter.filterName = 'objects';\n\nvar collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {\n if (!context || !context.children) {\n return;\n }\n if (context.delta._t) {\n return;\n }\n var length = context.children.length;\n var child;\n for (var index = 0; index < length; index++) {\n child = context.children[index];\n if (context.left.hasOwnProperty(child.childName) && child.result === undefined) {\n delete context.left[child.childName];\n } else if (context.left[child.childName] !== child.result) {\n context.left[child.childName] = child.result;\n }\n }\n context.setResult(context.left).exit();\n};\ncollectChildrenPatchFilter.filterName = 'collectChildren';\n\nvar reverseFilter = function nestedReverseFilter(context) {\n if (!context.nested) {\n return;\n }\n if (context.delta._t) {\n return;\n }\n var name, child;\n for (name in context.delta) {\n child = new ReverseContext(context.delta[name]);\n context.push(child, name);\n }\n context.exit();\n};\nreverseFilter.filterName = 'objects';\n\nvar collectChildrenReverseFilter = function collectChildrenReverseFilter(context) {\n if (!context || !context.children) {\n return;\n }\n if (context.delta._t) {\n return;\n }\n var length = context.children.length;\n var child;\n var delta = {};\n for (var index = 0; index < length; index++) {\n child = context.children[index];\n if (delta[child.childName] !== child.result) {\n delta[child.childName] = child.result;\n }\n }\n context.setResult(delta).exit();\n};\ncollectChildrenReverseFilter.filterName = 'collectChildren';\n\nexports.collectChildrenDiffFilter = collectChildrenDiffFilter;\nexports.objectsDiffFilter = objectsDiffFilter;\nexports.patchFilter = patchFilter;\nexports.collectChildrenPatchFilter = collectChildrenPatchFilter;\nexports.reverseFilter = reverseFilter;\nexports.collectChildrenReverseFilter = collectChildrenReverseFilter;\n","var DiffContext = require('../contexts/diff').DiffContext;\nvar PatchContext = require('../contexts/patch').PatchContext;\nvar ReverseContext = require('../contexts/reverse').ReverseContext;\n\nvar lcs = require('./lcs');\n\nvar ARRAY_MOVE = 3;\n\nvar isArray = (typeof Array.isArray === 'function') ?\n // use native function\n Array.isArray :\n // use instanceof operator\n function(a) {\n return a instanceof Array;\n };\n\nvar arrayIndexOf = typeof Array.prototype.indexOf === 'function' ?\n function(array, item) {\n return array.indexOf(item);\n } : function(array, item) {\n var length = array.length;\n for (var i = 0; i < length; i++) {\n if (array[i] === item) {\n return i;\n }\n }\n return -1;\n };\n\nfunction arraysHaveMatchByRef(array1, array2, len1, len2) {\n for (var index1 = 0; index1 < len1; index1++) {\n var val1 = array1[index1];\n for (var index2 = 0; index2 < len2; index2++) {\n var val2 = array2[index2];\n if (val1 === val2) {\n return true;\n }\n }\n }\n}\n\nfunction matchItems(array1, array2, index1, index2, context) {\n var value1 = array1[index1];\n var value2 = array2[index2];\n if (value1 === value2) {\n return true;\n }\n if (typeof value1 !== 'object' || typeof value2 !== 'object') {\n return false;\n }\n var objectHash = context.objectHash;\n if (!objectHash) {\n // no way to match objects was provided, try match by position\n return context.matchByPosition && index1 === index2;\n }\n var hash1;\n var hash2;\n if (typeof index1 === 'number') {\n context.hashCache1 = context.hashCache1 || [];\n hash1 = context.hashCache1[index1];\n if (typeof hash1 === 'undefined') {\n context.hashCache1[index1] = hash1 = objectHash(value1, index1);\n }\n } else {\n hash1 = objectHash(value1);\n }\n if (typeof hash1 === 'undefined') {\n return false;\n }\n if (typeof index2 === 'number') {\n context.hashCache2 = context.hashCache2 || [];\n hash2 = context.hashCache2[index2];\n if (typeof hash2 === 'undefined') {\n context.hashCache2[index2] = hash2 = objectHash(value2, index2);\n }\n } else {\n hash2 = objectHash(value2);\n }\n if (typeof hash2 === 'undefined') {\n return false;\n }\n return hash1 === hash2;\n}\n\nvar diffFilter = function arraysDiffFilter(context) {\n if (!context.leftIsArray) {\n return;\n }\n\n var matchContext = {\n objectHash: context.options && context.options.objectHash,\n matchByPosition: context.options && context.options.matchByPosition\n };\n var commonHead = 0;\n var commonTail = 0;\n var index;\n var index1;\n var index2;\n var array1 = context.left;\n var array2 = context.right;\n var len1 = array1.length;\n var len2 = array2.length;\n\n var child;\n\n if (len1 > 0 && len2 > 0 && !matchContext.objectHash &&\n typeof matchContext.matchByPosition !== 'boolean') {\n matchContext.matchByPosition = !arraysHaveMatchByRef(array1, array2, len1, len2);\n }\n\n // separate common head\n while (commonHead < len1 && commonHead < len2 &&\n matchItems(array1, array2, commonHead, commonHead, matchContext)) {\n index = commonHead;\n child = new DiffContext(context.left[index], context.right[index]);\n context.push(child, index);\n commonHead++;\n }\n // separate common tail\n while (commonTail + commonHead < len1 && commonTail + commonHead < len2 &&\n matchItems(array1, array2, len1 - 1 - commonTail, len2 - 1 - commonTail, matchContext)) {\n index1 = len1 - 1 - commonTail;\n index2 = len2 - 1 - commonTail;\n child = new DiffContext(context.left[index1], context.right[index2]);\n context.push(child, index2);\n commonTail++;\n }\n var result;\n if (commonHead + commonTail === len1) {\n if (len1 === len2) {\n // arrays are identical\n context.setResult(undefined).exit();\n return;\n }\n // trivial case, a block (1 or more consecutive items) was added\n result = result || {\n _t: 'a'\n };\n for (index = commonHead; index < len2 - commonTail; index++) {\n result[index] = [array2[index]];\n }\n context.setResult(result).exit();\n return;\n }\n if (commonHead + commonTail === len2) {\n // trivial case, a block (1 or more consecutive items) was removed\n result = result || {\n _t: 'a'\n };\n for (index = commonHead; index < len1 - commonTail; index++) {\n result['_' + index] = [array1[index], 0, 0];\n }\n context.setResult(result).exit();\n return;\n }\n // reset hash cache\n delete matchContext.hashCache1;\n delete matchContext.hashCache2;\n\n // diff is not trivial, find the LCS (Longest Common Subsequence)\n var trimmed1 = array1.slice(commonHead, len1 - commonTail);\n var trimmed2 = array2.slice(commonHead, len2 - commonTail);\n var seq = lcs.get(\n trimmed1, trimmed2,\n matchItems,\n matchContext\n );\n var removedItems = [];\n result = result || {\n _t: 'a'\n };\n for (index = commonHead; index < len1 - commonTail; index++) {\n if (arrayIndexOf(seq.indices1, index - commonHead) < 0) {\n // removed\n result['_' + index] = [array1[index], 0, 0];\n removedItems.push(index);\n }\n }\n\n var detectMove = true;\n if (context.options && context.options.arrays && context.options.arrays.detectMove === false) {\n detectMove = false;\n }\n var includeValueOnMove = false;\n if (context.options && context.options.arrays && context.options.arrays.includeValueOnMove) {\n includeValueOnMove = true;\n }\n\n var removedItemsLength = removedItems.length;\n for (index = commonHead; index < len2 - commonTail; index++) {\n var indexOnArray2 = arrayIndexOf(seq.indices2, index - commonHead);\n if (indexOnArray2 < 0) {\n // added, try to match with a removed item and register as position move\n var isMove = false;\n if (detectMove && removedItemsLength > 0) {\n for (var removeItemIndex1 = 0; removeItemIndex1 < removedItemsLength; removeItemIndex1++) {\n index1 = removedItems[removeItemIndex1];\n if (matchItems(trimmed1, trimmed2, index1 - commonHead,\n index - commonHead, matchContext)) {\n // store position move as: [originalValue, newPosition, ARRAY_MOVE]\n result['_' + index1].splice(1, 2, index, ARRAY_MOVE);\n if (!includeValueOnMove) {\n // don't include moved value on diff, to save bytes\n result['_' + index1][0] = '';\n }\n\n index2 = index;\n child = new DiffContext(context.left[index1], context.right[index2]);\n context.push(child, index2);\n removedItems.splice(removeItemIndex1, 1);\n isMove = true;\n break;\n }\n }\n }\n if (!isMove) {\n // added\n result[index] = [array2[index]];\n }\n } else {\n // match, do inner diff\n index1 = seq.indices1[indexOnArray2] + commonHead;\n index2 = seq.indices2[indexOnArray2] + commonHead;\n child = new DiffContext(context.left[index1], context.right[index2]);\n context.push(child, index2);\n }\n }\n\n context.setResult(result).exit();\n\n};\ndiffFilter.filterName = 'arrays';\n\nvar compare = {\n numerically: function(a, b) {\n return a - b;\n },\n numericallyBy: function(name) {\n return function(a, b) {\n return a[name] - b[name];\n };\n }\n};\n\nvar patchFilter = function nestedPatchFilter(context) {\n if (!context.nested) {\n return;\n }\n if (context.delta._t !== 'a') {\n return;\n }\n var index, index1;\n\n var delta = context.delta;\n var array = context.left;\n\n // first, separate removals, insertions and modifications\n var toRemove = [];\n var toInsert = [];\n var toModify = [];\n for (index in delta) {\n if (index !== '_t') {\n if (index[0] === '_') {\n // removed item from original array\n if (delta[index][2] === 0 || delta[index][2] === ARRAY_MOVE) {\n toRemove.push(parseInt(index.slice(1), 10));\n } else {\n throw new Error('only removal or move can be applied at original array indices' +\n ', invalid diff type: ' + delta[index][2]);\n }\n } else {\n if (delta[index].length === 1) {\n // added item at new array\n toInsert.push({\n index: parseInt(index, 10),\n value: delta[index][0]\n });\n } else {\n // modified item at new array\n toModify.push({\n index: parseInt(index, 10),\n delta: delta[index]\n });\n }\n }\n }\n }\n\n // remove items, in reverse order to avoid sawing our own floor\n toRemove = toRemove.sort(compare.numerically);\n for (index = toRemove.length - 1; index >= 0; index--) {\n index1 = toRemove[index];\n var indexDiff = delta['_' + index1];\n var removedValue = array.splice(index1, 1)[0];\n if (indexDiff[2] === ARRAY_MOVE) {\n // reinsert later\n toInsert.push({\n index: indexDiff[1],\n value: removedValue\n });\n }\n }\n\n // insert items, in reverse order to avoid moving our own floor\n toInsert = toInsert.sort(compare.numericallyBy('index'));\n var toInsertLength = toInsert.length;\n for (index = 0; index < toInsertLength; index++) {\n var insertion = toInsert[index];\n array.splice(insertion.index, 0, insertion.value);\n }\n\n // apply modifications\n var toModifyLength = toModify.length;\n var child;\n if (toModifyLength > 0) {\n for (index = 0; index < toModifyLength; index++) {\n var modification = toModify[index];\n child = new PatchContext(context.left[modification.index], modification.delta);\n context.push(child, modification.index);\n }\n }\n\n if (!context.children) {\n context.setResult(context.left).exit();\n return;\n }\n context.exit();\n};\npatchFilter.filterName = 'arrays';\n\nvar collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {\n if (!context || !context.children) {\n return;\n }\n if (context.delta._t !== 'a') {\n return;\n }\n var length = context.children.length;\n var child;\n for (var index = 0; index < length; index++) {\n child = context.children[index];\n context.left[child.childName] = child.result;\n }\n context.setResult(context.left).exit();\n};\ncollectChildrenPatchFilter.filterName = 'arraysCollectChildren';\n\nvar reverseFilter = function arraysReverseFilter(context) {\n if (!context.nested) {\n if (context.delta[2] === ARRAY_MOVE) {\n context.newName = '_' + context.delta[1];\n context.setResult([context.delta[0], parseInt(context.childName.substr(1), 10), ARRAY_MOVE]).exit();\n }\n return;\n }\n if (context.delta._t !== 'a') {\n return;\n }\n var name, child;\n for (name in context.delta) {\n if (name === '_t') {\n continue;\n }\n child = new ReverseContext(context.delta[name]);\n context.push(child, name);\n }\n context.exit();\n};\nreverseFilter.filterName = 'arrays';\n\nvar reverseArrayDeltaIndex = function(delta, index, itemDelta) {\n if (typeof index === 'string' && index[0] === '_') {\n return parseInt(index.substr(1), 10);\n } else if (isArray(itemDelta) && itemDelta[2] === 0) {\n return '_' + index;\n }\n\n var reverseIndex = +index;\n for (var deltaIndex in delta) {\n var deltaItem = delta[deltaIndex];\n if (isArray(deltaItem)) {\n if (deltaItem[2] === ARRAY_MOVE) {\n var moveFromIndex = parseInt(deltaIndex.substr(1), 10);\n var moveToIndex = deltaItem[1];\n if (moveToIndex === +index) {\n return moveFromIndex;\n }\n if (moveFromIndex <= reverseIndex && moveToIndex > reverseIndex) {\n reverseIndex++;\n } else if (moveFromIndex >= reverseIndex && moveToIndex < reverseIndex) {\n reverseIndex--;\n }\n } else if (deltaItem[2] === 0) {\n var deleteIndex = parseInt(deltaIndex.substr(1), 10);\n if (deleteIndex <= reverseIndex) {\n reverseIndex++;\n }\n } else if (deltaItem.length === 1 && deltaIndex <= reverseIndex) {\n reverseIndex--;\n }\n }\n }\n\n return reverseIndex;\n};\n\nvar collectChildrenReverseFilter = function collectChildrenReverseFilter(context) {\n if (!context || !context.children) {\n return;\n }\n if (context.delta._t !== 'a') {\n return;\n }\n var length = context.children.length;\n var child;\n var delta = {\n _t: 'a'\n };\n\n for (var index = 0; index < length; index++) {\n child = context.children[index];\n var name = child.newName;\n if (typeof name === 'undefined') {\n name = reverseArrayDeltaIndex(context.delta, child.childName, child.result);\n }\n if (delta[name] !== child.result) {\n delta[name] = child.result;\n }\n }\n context.setResult(delta).exit();\n};\ncollectChildrenReverseFilter.filterName = 'arraysCollectChildren';\n\nexports.diffFilter = diffFilter;\nexports.patchFilter = patchFilter;\nexports.collectChildrenPatchFilter = collectChildrenPatchFilter;\nexports.reverseFilter = reverseFilter;\nexports.collectChildrenReverseFilter = collectChildrenReverseFilter;\n","var diffFilter = function datesDiffFilter(context) {\n if (context.left instanceof Date) {\n if (context.right instanceof Date) {\n if (context.left.getTime() !== context.right.getTime()) {\n context.setResult([context.left, context.right]);\n } else {\n context.setResult(undefined);\n }\n } else {\n context.setResult([context.left, context.right]);\n }\n context.exit();\n } else if (context.right instanceof Date) {\n context.setResult([context.left, context.right]).exit();\n }\n};\ndiffFilter.filterName = 'dates';\n\nexports.diffFilter = diffFilter;\n","/* global diff_match_patch */\nvar TEXT_DIFF = 2;\nvar DEFAULT_MIN_LENGTH = 60;\nvar cachedDiffPatch = null;\n\nvar getDiffMatchPatch = function() {\n /*jshint camelcase: false */\n\n if (!cachedDiffPatch) {\n var instance;\n if (typeof diff_match_patch !== 'undefined') {\n // already loaded, probably a browser\n instance = typeof diff_match_patch === 'function' ?\n new diff_match_patch() : new diff_match_patch.diff_match_patch();\n } else if (typeof require === 'function') {\n try {\n var dmpModuleName = 'diff_match_patch_uncompressed';\n var dmp = require('../../public/external/' + dmpModuleName);\n instance = new dmp.diff_match_patch();\n } catch (err) {\n instance = null;\n }\n }\n if (!instance) {\n var error = new Error('text diff_match_patch library not found');\n error.diff_match_patch_not_found = true;\n throw error;\n }\n cachedDiffPatch = {\n diff: function(txt1, txt2) {\n return instance.patch_toText(instance.patch_make(txt1, txt2));\n },\n patch: function(txt1, patch) {\n var results = instance.patch_apply(instance.patch_fromText(patch), txt1);\n for (var i = 0; i < results[1].length; i++) {\n if (!results[1][i]) {\n var error = new Error('text patch failed');\n error.textPatchFailed = true;\n }\n }\n return results[0];\n }\n };\n }\n return cachedDiffPatch;\n};\n\nvar diffFilter = function textsDiffFilter(context) {\n if (context.leftType !== 'string') {\n return;\n }\n var minLength = (context.options && context.options.textDiff &&\n context.options.textDiff.minLength) || DEFAULT_MIN_LENGTH;\n if (context.left.length < minLength ||\n context.right.length < minLength) {\n context.setResult([context.left, context.right]).exit();\n return;\n }\n // large text, use a text-diff algorithm\n var diff = getDiffMatchPatch().diff;\n context.setResult([diff(context.left, context.right), 0, TEXT_DIFF]).exit();\n};\ndiffFilter.filterName = 'texts';\n\nvar patchFilter = function textsPatchFilter(context) {\n if (context.nested) {\n return;\n }\n if (context.delta[2] !== TEXT_DIFF) {\n return;\n }\n\n // text-diff, use a text-patch algorithm\n var patch = getDiffMatchPatch().patch;\n context.setResult(patch(context.left, context.delta[0])).exit();\n};\npatchFilter.filterName = 'texts';\n\nvar textDeltaReverse = function(delta) {\n var i, l, lines, line, lineTmp, header = null,\n headerRegex = /^@@ +\\-(\\d+),(\\d+) +\\+(\\d+),(\\d+) +@@$/,\n lineHeader, lineAdd, lineRemove;\n lines = delta.split('\\n');\n for (i = 0, l = lines.length; i < l; i++) {\n line = lines[i];\n var lineStart = line.slice(0, 1);\n if (lineStart === '@') {\n header = headerRegex.exec(line);\n lineHeader = i;\n lineAdd = null;\n lineRemove = null;\n\n // fix header\n lines[lineHeader] = '@@ -' + header[3] + ',' + header[4] + ' +' + header[1] + ',' + header[2] + ' @@';\n } else if (lineStart === '+') {\n lineAdd = i;\n lines[i] = '-' + lines[i].slice(1);\n if (lines[i - 1].slice(0, 1) === '+') {\n // swap lines to keep default order (-+)\n lineTmp = lines[i];\n lines[i] = lines[i - 1];\n lines[i - 1] = lineTmp;\n }\n } else if (lineStart === '-') {\n lineRemove = i;\n lines[i] = '+' + lines[i].slice(1);\n }\n }\n return lines.join('\\n');\n};\n\nvar reverseFilter = function textsReverseFilter(context) {\n if (context.nested) {\n return;\n }\n if (context.delta[2] !== TEXT_DIFF) {\n return;\n }\n\n // text-diff, use a text-diff algorithm\n context.setResult([textDeltaReverse(context.delta[0]), 0, TEXT_DIFF]).exit();\n};\nreverseFilter.filterName = 'texts';\n\nexports.diffFilter = diffFilter;\nexports.patchFilter = patchFilter;\nexports.reverseFilter = reverseFilter;\n","\nvar Pipe = require('../pipe').Pipe;\n\nvar Context = function Context(){\n};\n\nContext.prototype.setResult = function(result) {\n\tthis.result = result;\n\tthis.hasResult = true;\n\treturn this;\n};\n\nContext.prototype.exit = function() {\n\tthis.exiting = true;\n\treturn this;\n};\n\nContext.prototype.switchTo = function(next, pipe) {\n\tif (typeof next === 'string' || next instanceof Pipe) {\n\t\tthis.nextPipe = next;\n\t} else {\n\t\tthis.next = next;\n\t\tif (pipe) {\n\t\t\tthis.nextPipe = pipe;\n\t\t}\n\t}\n\treturn this;\n};\n\nContext.prototype.push = function(child, name) {\n\tchild.parent = this;\n\tif (typeof name !== 'undefined') {\n\t\tchild.childName = name;\n\t}\n\tchild.root = this.root || this;\n\tchild.options = child.options || this.options;\n\tif (!this.children) {\n\t\tthis.children = [child];\n\t\tthis.nextAfterChildren = this.next || null;\n\t\tthis.next = child;\n\t} else {\n\t\tthis.children[this.children.length - 1].next = child;\n\t\tthis.children.push(child);\n\t}\n\tchild.next = this;\n\treturn this;\n};\n\nexports.Context = Context;\n","/*\n\nLCS implementation that supports arrays or strings\n\nreference: http://en.wikipedia.org/wiki/Longest_common_subsequence_problem\n\n*/\n\nvar defaultMatch = function(array1, array2, index1, index2) {\n return array1[index1] === array2[index2];\n};\n\nvar lengthMatrix = function(array1, array2, match, context) {\n var len1 = array1.length;\n var len2 = array2.length;\n var x, y;\n\n // initialize empty matrix of len1+1 x len2+1\n var matrix = [len1 + 1];\n for (x = 0; x < len1 + 1; x++) {\n matrix[x] = [len2 + 1];\n for (y = 0; y < len2 + 1; y++) {\n matrix[x][y] = 0;\n }\n }\n matrix.match = match;\n // save sequence lengths for each coordinate\n for (x = 1; x < len1 + 1; x++) {\n for (y = 1; y < len2 + 1; y++) {\n if (match(array1, array2, x - 1, y - 1, context)) {\n matrix[x][y] = matrix[x - 1][y - 1] + 1;\n } else {\n matrix[x][y] = Math.max(matrix[x - 1][y], matrix[x][y - 1]);\n }\n }\n }\n return matrix;\n};\n\nvar backtrack = function(matrix, array1, array2, index1, index2, context) {\n if (index1 === 0 || index2 === 0) {\n return {\n sequence: [],\n indices1: [],\n indices2: []\n };\n }\n\n if (matrix.match(array1, array2, index1 - 1, index2 - 1, context)) {\n var subsequence = backtrack(matrix, array1, array2, index1 - 1, index2 - 1, context);\n subsequence.sequence.push(array1[index1 - 1]);\n subsequence.indices1.push(index1 - 1);\n subsequence.indices2.push(index2 - 1);\n return subsequence;\n }\n\n if (matrix[index1][index2 - 1] > matrix[index1 - 1][index2]) {\n return backtrack(matrix, array1, array2, index1, index2 - 1, context);\n } else {\n return backtrack(matrix, array1, array2, index1 - 1, index2, context);\n }\n};\n\nvar get = function(array1, array2, match, context) {\n context = context || {};\n var matrix = lengthMatrix(array1, array2, match || defaultMatch, context);\n var result = backtrack(matrix, array1, array2, array1.length, array2.length, context);\n if (typeof array1 === 'string' && typeof array2 === 'string') {\n result.sequence = result.sequence.join('');\n }\n return result;\n};\n\nexports.get = get;\n"]}