{"version":3,"sources":["webpack:///./node_modules/util/node_modules/inherits/inherits_browser.js","webpack:///./node_modules/util/util.js","webpack:///./node_modules/diff-match-patch/index.js","webpack:///./node_modules/util/support/isBufferBrowser.js"],"names":["Object","create","module","exports","ctor","superCtor","super_","prototype","constructor","value","enumerable","writable","configurable","TempCtor","getOwnPropertyDescriptors","obj","keys","descriptors","i","length","getOwnPropertyDescriptor","formatRegExp","format","f","isString","objects","arguments","push","inspect","join","args","len","str","String","replace","x","Number","JSON","stringify","_","isNull","isObject","deprecate","fn","msg","process","noDeprecation","apply","this","warned","deprecated","throwDeprecation","Error","traceDeprecation","console","trace","error","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","arrayToHash","array","hash","forEach","val","idx","recurseTimes","isFunction","ret","primitive","formatPrimitive","visibleKeys","getOwnPropertyNames","isError","indexOf","formatError","name","isRegExp","RegExp","toString","call","isDate","Date","output","base","braces","isArray","n","toUTCString","formatArray","map","key","formatProperty","pop","reduceToSingleString","simple","isNumber","l","hasOwnProperty","match","desc","get","set","split","line","substr","reduce","prev","cur","numLinesEst","ar","Array","arg","isNullOrUndefined","isSymbol","re","objectToString","d","e","isPrimitive","o","pad","debuglog","NODE_DEBUG","toUpperCase","test","pid","isBuffer","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","prop","log","inherits","origin","add","kCustomPromisifiedSymbol","Symbol","undefined","callbackifyOnRejected","reason","cb","newReason","callbackify","original","TypeError","callbackified","maybeCb","self","then","nextTick","rej","setPrototypeOf","getPrototypeOf","defineProperties","promisify","defineProperty","promiseResolve","promiseReject","promise","Promise","resolve","reject","err","custom","diff_match_patch","Diff_Timeout","Diff_EditCost","Match_Threshold","Match_Distance","Patch_DeleteThreshold","Patch_Margin","Match_MaxBits","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","Diff","op","text","diff_main","text1","text2","opt_checklines","opt_deadline","MAX_VALUE","getTime","deadline","checklines","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diffs","diff_compute_","unshift","diff_cleanupMerge","longtext","shorttext","hm","diff_halfMatch_","text1_a","text1_b","text2_a","text2_b","mid_common","diffs_a","diffs_b","concat","diff_lineMode_","diff_bisect_","a","diff_linesToChars_","chars1","chars2","linearray","lineArray","diff_charsToLines_","diff_cleanupSemantic","pointer","count_delete","count_insert","text_delete","text_insert","splice","subDiff","j","text1_length","text2_length","max_d","Math","ceil","v_offset","v_length","v1","v2","delta","front","k1start","k1end","k2start","k2end","k1","k1_offset","x1","y1","charAt","k2_offset","x2","diff_bisectSplit_","k2","y2","y","text1a","text2a","text1b","text2b","diffsb","lineHash","diff_linesToCharsMunge_","chars","lineStart","lineEnd","lineArrayLength","fromCharCode","maxLines","charCodeAt","pointermin","pointermax","min","pointermid","pointerstart","floor","pointerend","diff_commonOverlap_","text_length","best","pattern","found","dmp","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","best_common","prefixLength","suffixLength","hm1","hm2","changes","equalities","equalitiesLength","lastEquality","length_insertions1","length_deletions1","length_insertions2","length_deletions2","max","diff_cleanupSemanticLossless","deletion","insertion","overlap_length1","overlap_length2","diff_cleanupSemanticScore_","one","two","char1","char2","nonAlphaNumeric1","nonAlphaNumericRegex_","nonAlphaNumeric2","whitespace1","whitespaceRegex_","whitespace2","lineBreak1","linebreakRegex_","lineBreak2","blankLine1","blanklineEndRegex_","blankLine2","blanklineStartRegex_","equality1","edit","equality2","commonOffset","commonString","bestEquality1","bestEdit","bestEquality2","bestScore","score","diff_cleanupEfficiency","pre_ins","pre_del","post_ins","post_del","diff_xIndex","loc","last_chars1","last_chars2","diff_prettyHtml","html","pattern_amp","pattern_lt","pattern_gt","pattern_para","data","diff_text1","diff_text2","diff_levenshtein","levenshtein","insertions","deletions","diff_toDelta","encodeURI","diff_fromDelta","diffsLength","tokens","param","decodeURI","ex","parseInt","isNaN","match_main","match_bitap_","s","match_alphabet_","match_bitapScore_","accuracy","proximity","abs","score_threshold","best_loc","lastIndexOf","bin_min","bin_mid","matchmask","last_rd","bin_max","start","finish","rd","charMatch","patch_addContext_","patch","start2","length1","padding","prefix","suffix","start1","length2","patch_make","opt_b","opt_c","patches","patch_obj","patchDiffLength","char_count1","char_count2","prepatch_text","postpatch_text","diff_type","diff_text","patch_deepCopy","patchesCopy","patchCopy","patch_apply","nullPadding","patch_addPadding","patch_splitMax","results","start_loc","expected_loc","end_loc","index2","index1","mod","paddingLength","extraLength","patch_size","bigpatch","precontext","empty","shift","postcontext","patch_toText","patch_fromText","textline","textPointer","patchHeader","m","sign","coords1","coords2","copy","fill","readUInt8"],"mappings":"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","file":"js/group-admin-mailing-page~b5906859.5c4d111d.js","sourcesContent":["if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb, null, ret) },\n            function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","/**\n * Diff Match and Patch\n * Copyright 2018 The diff-match-patch Authors.\n * https://github.com/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 */\nvar diff_match_patch = function() {\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 do\n  // the contents have to be to match the expected contents. (0.0 = perfection,\n  // 1.0 = very loose).  Note that Match_Threshold controls how closely the\n  // end points of a delete need to match.\n  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/**\n * Class representing one diff tuple.\n * ~Attempts to look like a two-element array (which is what this used to be).~\n * Constructor returns an actual two-element array, to allow destructing @JackuB\n * See https://github.com/JackuB/diff-match-patch/issues/14 for details\n * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.\n * @param {string} text Text to be deleted, inserted, or retained.\n * @constructor\n */\ndiff_match_patch.Diff = function(op, text) {\n  return [op, text];\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 [new diff_match_patch.Diff(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(new diff_match_patch.Diff(DIFF_EQUAL, commonprefix));\n  }\n  if (commonsuffix) {\n    diffs.push(new diff_match_patch.Diff(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 [new diff_match_patch.Diff(DIFF_INSERT, text2)];\n  }\n\n  if (!text2) {\n    // Just delete some text (speedup).\n    return [new diff_match_patch.Diff(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 = [new diff_match_patch.Diff(DIFF_INSERT, longtext.substring(0, i)),\n             new diff_match_patch.Diff(DIFF_EQUAL, shorttext),\n             new diff_match_patch.Diff(DIFF_INSERT,\n                 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 [new diff_match_patch.Diff(DIFF_DELETE, text1),\n            new diff_match_patch.Diff(DIFF_INSERT, text2)];\n  }\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([new diff_match_patch.Diff(DIFF_EQUAL, mid_common)],\n                          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 = a.chars1;\n  text2 = a.chars2;\n  var linearray = a.lineArray;\n\n  var diffs = this.diff_main(text1, text2, false, deadline);\n\n  // Convert the diff back to original text.\n  this.diff_charsToLines_(diffs, linearray);\n  // Eliminate freak matches (e.g. blank lines)\n  this.diff_cleanupSemantic(diffs);\n\n  // Rediff any replacement blocks, this time character-by-character.\n  // Add a dummy entry at the end.\n  diffs.push(new diff_match_patch.Diff(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          diffs.splice(pointer - count_delete - count_insert,\n                       count_delete + count_insert);\n          pointer = pointer - count_delete - count_insert;\n          var subDiff =\n              this.diff_main(text_delete, text_insert, false, deadline);\n          for (var j = subDiff.length - 1; j >= 0; j--) {\n            diffs.splice(pointer, 0, subDiff[j]);\n          }\n          pointer = pointer + subDiff.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 [new diff_match_patch.Diff(DIFF_DELETE, text1),\n          new diff_match_patch.Diff(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 {{chars1: string, chars2: string, lineArray: !Array.<string>}}\n *     An object containing the encoded text1, the encoded text2 and\n *     the array of unique strings.\n *     The zeroth element of the array of unique strings is intentionally blank.\n * @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\n      if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :\n          (lineHash[line] !== undefined)) {\n        chars += String.fromCharCode(lineHash[line]);\n      } else {\n        if (lineArrayLength == maxLines) {\n          // Bail out at 65535 because\n          // String.fromCharCode(65536) == String.fromCharCode(0)\n          line = text.substring(lineStart);\n          lineEnd = text.length;\n        }\n        chars += String.fromCharCode(lineArrayLength);\n        lineHash[line] = lineArrayLength;\n        lineArray[lineArrayLength++] = line;\n      }\n      lineStart = lineEnd + 1;\n    }\n    return chars;\n  }\n  // Allocate 2/3rds of the space for text1, the rest for text2.\n  var maxLines = 40000;\n  var chars1 = diff_linesToCharsMunge_(text1);\n  maxLines = 65535;\n  var chars2 = diff_linesToCharsMunge_(text2);\n  return {chars1: chars1, chars2: chars2, lineArray: 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 i = 0; i < diffs.length; i++) {\n    var chars = diffs[i][1];\n    var text = [];\n    for (var j = 0; j < chars.length; j++) {\n      text[j] = lineArray[chars.charCodeAt(j)];\n    }\n    diffs[i][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: https://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: https://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: https://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;\n  // Always equal to diffs[equalities[equalitiesLength - 1]][1]\n  var pointer = 0;  // Index of current position.\n  // Number of characters that changed prior to the equality.\n  var length_insertions1 = 0;\n  var length_deletions1 = 0;\n  // Number of characters that changed after the equality.\n  var length_insertions2 = 0;\n  var length_deletions2 = 0;\n  while (pointer < diffs.length) {\n    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.\n      equalities[equalitiesLength++] = pointer;\n      length_insertions1 = length_insertions2;\n      length_deletions1 = length_deletions2;\n      length_insertions2 = 0;\n      length_deletions2 = 0;\n      lastEquality = diffs[pointer][1];\n    } else {  // An insertion or deletion.\n      if (diffs[pointer][0] == 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 && (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                     new diff_match_patch.Diff(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  // e.g: <del>xxxabc</del><ins>defxxx</ins>\n  //   -> <ins>def</ins>xxx<del>abc</del>\n  // Only extract an overlap if it is as big as the edit ahead or behind it.\n  pointer = 1;\n  while (pointer < diffs.length) {\n    if (diffs[pointer - 1][0] == DIFF_DELETE &&\n        diffs[pointer][0] == DIFF_INSERT) {\n      var deletion = diffs[pointer - 1][1];\n      var insertion = diffs[pointer][1];\n      var overlap_length1 = this.diff_commonOverlap_(deletion, insertion);\n      var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);\n      if (overlap_length1 >= overlap_length2) {\n        if (overlap_length1 >= deletion.length / 2 ||\n            overlap_length1 >= insertion.length / 2) {\n          // Overlap found.  Insert an equality and trim the surrounding edits.\n          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n              insertion.substring(0, overlap_length1)));\n          diffs[pointer - 1][1] =\n              deletion.substring(0, deletion.length - overlap_length1);\n          diffs[pointer + 1][1] = insertion.substring(overlap_length1);\n          pointer++;\n        }\n      } else {\n        if (overlap_length2 >= deletion.length / 2 ||\n            overlap_length2 >= insertion.length / 2) {\n          // Reverse overlap found.\n          // Insert an equality and swap and trim the surrounding edits.\n          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n              deletion.substring(0, overlap_length2)));\n          diffs[pointer - 1][0] = DIFF_INSERT;\n          diffs[pointer - 1][1] =\n              insertion.substring(0, insertion.length - overlap_length2);\n          diffs[pointer + 1][0] = DIFF_DELETE;\n          diffs[pointer + 1][1] =\n              deletion.substring(overlap_length2);\n          pointer++;\n        }\n      }\n      pointer++;\n    }\n    pointer++;\n  }\n};\n\n\n/**\n * Look for single edits surrounded on both sides by equalities\n * which can be shifted sideways to align the edit to a word boundary.\n * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {\n  /**\n   * Given two strings, compute a score representing whether the internal\n   * boundary falls on logical boundaries.\n   * Scores range from 6 (best) to 0 (worst).\n   * Closure, but does not reference any external variables.\n   * @param {string} one First string.\n   * @param {string} two Second string.\n   * @return {number} The score.\n   * @private\n   */\n  function diff_cleanupSemanticScore_(one, two) {\n    if (!one || !two) {\n      // Edges are the best.\n      return 6;\n    }\n\n    // Each port of this function behaves slightly differently due to\n    // subtle differences in each language's definition of things like\n    // 'whitespace'.  Since this function's purpose is largely cosmetic,\n    // the choice has been made to use each language's native features\n    // rather than force total conformity.\n    var char1 = one.charAt(one.length - 1);\n    var char2 = two.charAt(0);\n    var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_);\n    var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_);\n    var whitespace1 = nonAlphaNumeric1 &&\n        char1.match(diff_match_patch.whitespaceRegex_);\n    var whitespace2 = nonAlphaNumeric2 &&\n        char2.match(diff_match_patch.whitespaceRegex_);\n    var lineBreak1 = whitespace1 &&\n        char1.match(diff_match_patch.linebreakRegex_);\n    var lineBreak2 = whitespace2 &&\n        char2.match(diff_match_patch.linebreakRegex_);\n    var blankLine1 = lineBreak1 &&\n        one.match(diff_match_patch.blanklineEndRegex_);\n    var blankLine2 = lineBreak2 &&\n        two.match(diff_match_patch.blanklineStartRegex_);\n\n    if (blankLine1 || blankLine2) {\n      // Five points for blank lines.\n      return 5;\n    } else if (lineBreak1 || lineBreak2) {\n      // Four points for line breaks.\n      return 4;\n    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\n      // Three points for end of sentences.\n      return 3;\n    } else if (whitespace1 || whitespace2) {\n      // Two points for whitespace.\n      return 2;\n    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\n      // One point for non-alphanumeric.\n      return 1;\n    }\n    return 0;\n  }\n\n  var pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (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 = diffs[pointer - 1][1];\n      var edit = diffs[pointer][1];\n      var equality2 = diffs[pointer + 1][1];\n\n      // First, shift the edit as far left as possible.\n      var commonOffset = 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// Define some regex patterns for matching boundaries.\ndiff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\ndiff_match_patch.whitespaceRegex_ = /\\s/;\ndiff_match_patch.linebreakRegex_ = /[\\r\\n]/;\ndiff_match_patch.blanklineEndRegex_ = /\\n\\r?\\n$/;\ndiff_match_patch.blanklineStartRegex_ = /^\\r?\\n\\r?\\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  /** @type {?string} */\n  var lastEquality = null;\n  // Always equal to diffs[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 = null;\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                     new diff_match_patch.Diff(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 = null;\n        if (pre_ins && pre_del) {\n          // No changes made which could affect previous entry, keep going.\n          post_ins = post_del = true;\n          equalitiesLength = 0;\n        } else {\n          equalitiesLength--;  // Throw away the previous equality.\n          pointer = equalitiesLength > 0 ?\n              equalities[equalitiesLength - 1] : -1;\n          post_ins = post_del = false;\n        }\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n\n  if (changes) {\n    this.diff_cleanupMerge(diffs);\n  }\n};\n\n\n/**\n * Reorder and merge like edit sections.  Merge equalities.\n * Any edit section can move as long as it doesn't cross an equality.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupMerge = function(diffs) {\n  // Add a dummy entry at the end.\n  diffs.push(new diff_match_patch.Diff(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  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, new diff_match_patch.Diff(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          pointer -= count_delete + count_insert;\n          diffs.splice(pointer, count_delete + count_insert);\n          if (text_delete.length) {\n            diffs.splice(pointer, 0,\n                new diff_match_patch.Diff(DIFF_DELETE, text_delete));\n            pointer++;\n          }\n          if (text_insert.length) {\n            diffs.splice(pointer, 0,\n                new diff_match_patch.Diff(DIFF_INSERT, text_insert));\n            pointer++;\n          }\n          pointer++;\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 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  }\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++] =\n              new diff_match_patch.Diff(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++] = new diff_match_patch.Diff(DIFF_EQUAL, text);\n        } else {\n          diffs[diffsLength++] = new diff_match_patch.Diff(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  if (patch.start2 === null) {\n    throw Error('patch not initialized');\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(new diff_match_patch.Diff(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(new diff_match_patch.Diff(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            // https://github.com/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] =\n          new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]);\n    }\n    patchCopy.start1 = patch.start1;\n    patchCopy.start2 = patch.start2;\n    patchCopy.length1 = patch.length1;\n    patchCopy.length2 = patch.length2;\n    patchesCopy[x] = patchCopy;\n  }\n  return patchesCopy;\n};\n\n\n/**\n * Merge a set of patches onto the text.  Return a patched text, as well\n * as a list of true/false values indicating which patches were applied.\n * @param {!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(new diff_match_patch.Diff(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(new diff_match_patch.Diff(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      continue;\n    }\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(new diff_match_patch.Diff(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(new diff_match_patch.Diff(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(new diff_match_patch.Diff(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(new diff_match_patch.Diff(DIFF_EQUAL, postcontext));\n        }\n      }\n      if (!empty) {\n        patches.splice(++x, 0, patch);\n      }\n    }\n  }\n};\n\n\n/**\n * Take a list of patches and return a textual representation.\n * @param {!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(new diff_match_patch.Diff(DIFF_DELETE, line));\n      } else if (sign == '+') {\n        // Insertion.\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_INSERT, line));\n      } else if (sign == ' ') {\n        // Minor equality.\n        patch.diffs.push(new diff_match_patch.Diff(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 * Emulate GNU diff's format.\n * Header: @@ -382,8 +481,9 @@\n * Indices 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// The following export code was added by @ForbesLindesay\nmodule.exports = diff_match_patch;\nmodule.exports['diff_match_patch'] = diff_match_patch;\nmodule.exports['DIFF_DELETE'] = DIFF_DELETE;\nmodule.exports['DIFF_INSERT'] = DIFF_INSERT;\nmodule.exports['DIFF_EQUAL'] = DIFF_EQUAL;","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}"],"sourceRoot":""}