{"version":3,"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/patch.js","/source-files/jsondiffpatch/src/contexts/reverse.js","/source-files/jsondiffpatch/src/clone.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":["environment","require","isBrowser","window","diff_match_patch","module","exports","DiffPatcher","create","options","dateReviver","defaultInstance","diff","apply","arguments","patch","unpatch","reverse","clone","homepage","version","packageInfoModuleName","packageInfo","formatterModuleName","formatters","console","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","value","key","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","defaultClone","setResult","cloneDiffValues","cloneRegExp","re","regexMatch","RegExp","arg","isArray","map","cloned","Object","exit","leftType","rightType","leftIsArray","rightIsArray","regexArgs","children","child","childName","_t","propertyFilter","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","required","instance","dmpModuleName","err","diff_match_patch_not_found","txt1","txt2","textPatchFailed","minLength","textDiff","diffMatchPatch","textDeltaReverse","l","lines","lineTmp","lineHeader","lineAdd","lineRemove","header","headerRegex","switchTo","parent","root","defaultMatch","lengthMatrix","matrix","backtrack","sequence","subsequence"],"mappings":"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","file":"bundle.js","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<r.length;o++)s(r[o]);return s})","var environment = require('./environment');\n\nif (environment.isBrowser) {\n  /* global window */\n  /* jshint camelcase: false */\n  window.diff_match_patch = require('../public/external/diff_match_patch_uncompressed');\n  /* jshint camelcase: true */\n}\n\nmodule.exports = require('./main');\n","\nexports.isBrowser = typeof window !== 'undefined';\n","\nvar environment = require('./environment');\n\nvar DiffPatcher = require('./diffpatcher').DiffPatcher;\nexports.DiffPatcher = DiffPatcher;\n\nexports.create = function(options){\n  return new DiffPatcher(options);\n};\n\nexports.dateReviver = require('./date-reviver');\n\nvar defaultInstance;\n\nexports.diff = function() {\n  if (!defaultInstance) {\n    defaultInstance = new DiffPatcher();\n  }\n  return defaultInstance.diff.apply(defaultInstance, arguments);\n};\n\nexports.patch = function() {\n  if (!defaultInstance) {\n    defaultInstance = new DiffPatcher();\n  }\n  return defaultInstance.patch.apply(defaultInstance, arguments);\n};\n\nexports.unpatch = function() {\n  if (!defaultInstance) {\n    defaultInstance = new DiffPatcher();\n  }\n  return defaultInstance.unpatch.apply(defaultInstance, arguments);\n};\n\nexports.reverse = function() {\n  if (!defaultInstance) {\n    defaultInstance = new DiffPatcher();\n  }\n  return defaultInstance.reverse.apply(defaultInstance, arguments);\n};\n\nexports.clone = function() {\n  if (!defaultInstance) {\n    defaultInstance = new DiffPatcher();\n  }\n  return defaultInstance.clone.apply(defaultInstance, arguments);\n};\n\n\nif (environment.isBrowser) {\n  exports.homepage = '{{package-homepage}}';\n  exports.version = '{{package-version}}';\n} else {\n  var packageInfoModuleName = '../package.json';\n  var packageInfo = require(packageInfoModuleName);\n  exports.homepage = packageInfo.homepage;\n  exports.version = packageInfo.version;\n\n  var formatterModuleName = './formatters';\n  var formatters = require(formatterModuleName);\n  exports.formatters = formatters;\n  // shortcut for console\n  exports.console = formatters.console;\n}\n","/**\n * Diff Match and Patch\n *\n * Copyright 2006 Google Inc.\n * http://code.google.com/p/google-diff-match-patch/\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Computes the difference between two texts to create a patch.\n * Applies the patch onto another text, allowing for errors.\n * @author fraser@google.com (Neil Fraser)\n */\n\n/**\n * Class containing the diff, match and patch methods.\n * @constructor\n */\nfunction diff_match_patch() {\n\n  // Defaults.\n  // Redefine these in your program to override the defaults.\n\n  // Number of seconds to map a diff before giving up (0 for infinity).\n  this.Diff_Timeout = 1.0;\n  // Cost of an empty edit operation in terms of edit characters.\n  this.Diff_EditCost = 4;\n  // At what point is no match declared (0.0 = perfection, 1.0 = very loose).\n  this.Match_Threshold = 0.5;\n  // How far to search for a match (0 = exact location, 1000+ = broad match).\n  // A match this many characters away from the expected location will add\n  // 1.0 to the score (0.0 is a perfect match).\n  this.Match_Distance = 1000;\n  // When deleting a large block of text (over ~64 characters), how close does\n  // the contents have to match the expected contents. (0.0 = perfection,\n  // 1.0 = very loose).  Note that Match_Threshold controls how closely the\n  // end points of a delete need to match.\n  this.Patch_DeleteThreshold = 0.5;\n  // Chunk size for context length.\n  this.Patch_Margin = 4;\n\n  // The number of bits in an int.\n  this.Match_MaxBits = 32;\n}\n\n\n//  DIFF FUNCTIONS\n\n\n/**\n * The data structure representing a diff is an array of tuples:\n * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\n * which means: delete 'Hello', add 'Goodbye' and keep ' world.'\n */\nvar DIFF_DELETE = -1;\nvar DIFF_INSERT = 1;\nvar DIFF_EQUAL = 0;\n\n/** @typedef {!Array.<number|string>} */\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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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.<string>} */(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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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.<string|!Array.<string>>} 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.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @param {!Array.<string>} 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.<string>} Five element Array, containing the prefix of\n *     text1, the suffix of text1, the prefix of text2, the suffix of\n *     text2 and the common middle.  Or null if there was no match.\n * @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.<string>} Five element Array, containing the prefix of\n   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix\n   *     of shorttext and the common middle.  Or null if there was no match.\n   * @private\n   */\n  function diff_halfMatchI_(longtext, shorttext, i) {\n    // Start with a 1/4 length substring at position i as a seed.\n    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\n    var j = -1;\n    var best_common = '';\n    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\n    while ((j = shorttext.indexOf(seed, j + 1)) != -1) {\n      var prefixLength = 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.<!diff_match_patch.Diff>} 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: <del>abcxxx</del><ins>xxxdef</ins>\n  //   -> <del>abc</del>xxx<ins>def</ins>\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 c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\n * @param {!Array.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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       * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>\n       * <ins>A</ins>X<ins>C</ins><del>D</del>\n       * <ins>A</ins><del>B</del>X<ins>C</ins>\n       * <ins>A</del>X<ins>C</ins><del>D</del>\n       * <ins>A</ins><del>B</del>X<del>C</del>\n       */\n      if (lastequality && ((pre_ins && pre_del && post_ins && post_del) ||\n                           ((lastequality.length < this.Diff_EditCost / 2) &&\n                            (pre_ins + 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.<!diff_match_patch.Diff>} 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: A<ins>BA</ins>C -> <ins>AB</ins>AC\n  var changes = false;\n  pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n        diffs[pointer + 1][0] == DIFF_EQUAL) {\n      // This is a single edit surrounded by equalities.\n      if (diffs[pointer][1].substring(diffs[pointer][1].length -\n          diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {\n        // Shift the edit over the previous equality.\n        diffs[pointer][1] = diffs[pointer - 1][1] +\n            diffs[pointer][1].substring(0, diffs[pointer][1].length -\n                                        diffs[pointer - 1][1].length);\n        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n        diffs.splice(pointer - 1, 1);\n        changes = true;\n      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n          diffs[pointer + 1][1]) {\n        // Shift the edit over the next equality.\n        diffs[pointer - 1][1] += diffs[pointer + 1][1];\n        diffs[pointer][1] =\n            diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\n            diffs[pointer + 1][1];\n        diffs.splice(pointer + 1, 1);\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n  // If shifts were made, the diff needs reordering and another shift sweep.\n  if (changes) {\n    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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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_gt = />/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, '&amp;').replace(pattern_lt, '&lt;')\n        .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');\n    switch (op) {\n      case DIFF_INSERT:\n        html[x] = '<ins style=\"background:#e6ffe6;\">' + text + '</ins>';\n        break;\n      case DIFF_DELETE:\n        html[x] = '<del style=\"background:#ffe6e6;\">' + text + '</del>';\n        break;\n      case DIFF_EQUAL:\n        html[x] = '<span>' + text + '</span>';\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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} a text1 (methods 1,3,4) or\n * Array of diff tuples for text1 to text2 (method 2).\n * @param {string|!Array.<!diff_match_patch.Diff>} 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.<!diff_match_patch.Diff>} opt_c Array of diff tuples\n * for text1 to text2 (method 4) or undefined (methods 1,2,3).\n * @return {!Array.<!diff_match_patch.patch_obj>} 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.<!diff_match_patch.Diff>} */(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.<!diff_match_patch.Diff>} */(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.<!diff_match_patch.Diff>} */(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.<!diff_match_patch.patch_obj>} patches Array of patch objects.\n * @return {!Array.<!diff_match_patch.patch_obj>} 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.<!diff_match_patch.patch_obj>} patches Array of patch objects.\n * @param {string} text Old text.\n * @return {!Array.<string|!Array.<boolean>>} 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.<!diff_match_patch.patch_obj>} 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.<!diff_match_patch.patch_obj>} 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.<!diff_match_patch.patch_obj>} 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.<!diff_match_patch.patch_obj>} 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.<!diff_match_patch.Diff>} */\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 clone = require('./clone');\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\nDiffPatcher.prototype.clone = function(value) {\n  return clone(value);\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  this.selfOptions = options || {};\n  this.pipes = {};\n};\n\nProcessor.prototype.options = function(options) {\n  if (options) {\n    this.selfOptions = options;\n  }\n  return this.selfOptions;\n};\n\nProcessor.prototype.pipe = function(name, pipe) {\n  if (typeof name === 'string') {\n    if (typeof pipe === 'undefined') {\n      return this.pipes[name];\n    } else {\n      this.pipes[name] = pipe;\n    }\n  }\n  if (name && name.name) {\n    pipe = name;\n    if (pipe.processor === this) { return pipe; }\n    this.pipes[pipe.name] = pipe;\n  }\n  pipe.processor = this;\n  return pipe;\n};\n\nProcessor.prototype.process = function(input, pipe) {\n  var context = input;\n  context.options = this.options();\n  var nextPipe = pipe || input.pipe || 'default';\n  var lastPipe, lastContext;\n  while (nextPipe) {\n    if (typeof context.nextAfterChildren !== 'undefined') {\n      // children processed and coming back to parent\n      context.next = context.nextAfterChildren;\n      context.nextAfterChildren = null;\n    }\n\n    if (typeof nextPipe === 'string') {\n      nextPipe = this.pipe(nextPipe);\n    }\n    nextPipe.process(context);\n    lastContext = context;\n    lastPipe = nextPipe;\n    nextPipe = null;\n    if (context) {\n      if (context.next) {\n        context = context.next;\n        nextPipe = lastContext.nextPipe || context.pipe || lastPipe;\n      }\n    }\n  }\n  return 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;\nvar defaultClone = require('../clone');\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\nDiffContext.prototype.setResult = function(result) {\n  if (this.options.cloneDiffValues) {\n    var clone = typeof this.options.cloneDiffValues === 'function' ?\n      this.options.cloneDiffValues : defaultClone;\n    if (typeof result[0] === 'object') {\n      result[0] = clone(result[0]);\n    }\n    if (typeof result[1] === 'object') {\n      result[1] = clone(result[1]);\n    }\n  }\n  return Context.prototype.setResult.apply(this, arguments);\n};\n\nexports.DiffContext = DiffContext;\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 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","\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\nfunction cloneRegExp(re) {\n  var regexMatch = /^\\/(.*)\\/([gimyu]*)$/.exec(re.toString());\n  return new RegExp(regexMatch[1], regexMatch[2]);\n}\n\nfunction clone(arg) {\n  if (typeof arg !== 'object') {\n    return arg;\n  }\n  if (arg === null) {\n    return null;\n  }\n  if (isArray(arg)) {\n    return arg.map(clone);\n  }\n  if (arg instanceof Date) {\n    return new Date(arg.getTime());\n  }\n  if (arg instanceof RegExp) {\n    return cloneRegExp(arg);\n  }\n  var cloned = {};\n  for (var name in arg) {\n    if (Object.prototype.hasOwnProperty.call(arg, name)) {\n      cloned[name] = clone(arg[name]);\n    }\n  }\n  return cloned;\n}\n\nmodule.exports = clone;\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\n  if (context.left instanceof RegExp) {\n    if (context.right instanceof RegExp) {\n      context.setResult([context.left.toString(), context.right.toString()]).exit();\n    } else {\n      context.setResult([context.left, context.right]).exit();\n      return;\n    }\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    if (context.left instanceof RegExp) {\n      var regexArgs = /^\\/(.*)\\/([gimyu]+)$/.exec(context.delta[1]);\n      if (regexArgs) {\n        context.setResult(new RegExp(regexArgs[1], regexArgs[2])).exit();\n        return;\n      }\n    }\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, propertyFilter = context.options.propertyFilter;\n  for (name in context.left) {\n    if (!Object.prototype.hasOwnProperty.call(context.left, name)) {\n      continue;\n    }\n    if (propertyFilter && !propertyFilter(name, context)) {\n      continue;\n    }\n    child = new DiffContext(context.left[name], context.right[name]);\n    context.push(child, name);\n  }\n  for (name in context.right) {\n    if (!Object.prototype.hasOwnProperty.call(context.right, name)) {\n      continue;\n    }\n    if (propertyFilter && !propertyFilter(name, context)) {\n      continue;\n    }\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 (Object.prototype.hasOwnProperty.call(context.left, 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(required) {\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      if (!required) {\n        return null;\n      }\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, try to use a text-diff algorithm\n  var diffMatchPatch = getDiffMatchPatch();\n  if (!diffMatchPatch) {\n    // diff-match-patch library not available, fallback to regular string replace\n    context.setResult([context.left, context.right]).exit();\n    return;\n  }\n  var diff = diffMatchPatch.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(true).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"]}