{"mappings":"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","names":["require_diff","__commonJSMin","exports","module","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","diff_main","text1","text2","cursor_pos","cleanup","_fix_unicode","editdiff","find_cursor_edit_diff","commonlength","diff_commonPrefix","commonprefix","diff_commonSuffix","commonsuffix","diffs","diff_compute_","diff_cleanupMerge","diff_cleanupSemantic","longtext","shorttext","hm","diff_halfMatch_","text1_a","text1_b","text2_a","text2_b","mid_common","diffs_a","diffs_b","diff_bisect_","text1_length","text2_length","max_d","v_offset","v_length","v1","v2","x","delta","front","k1start","k1end","k2start","k2end","d","k1","k1_offset","x1","y1","k2_offset","x2","diff_bisectSplit_","k2","y2","y","text1a","text2a","text1b","text2b","diffsb","pointermin","pointermax","pointermid","pointerstart","is_surrogate_pair_start","diff_commonOverlap_","text_length","best","length","pattern","found","pointerend","is_surrogate_pair_end","diff_halfMatchI_","i","seed","j","best_common","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","prefixLength","suffixLength","hm1","hm2","changes","equalities","equalitiesLength","lastequality","pointer","length_insertions1","length_deletions1","length_insertions2","length_deletions2","diff_cleanupSemanticLossless","deletion","insertion","overlap_length1","overlap_length2","nonAlphaNumericRegex_","whitespaceRegex_","linebreakRegex_","blanklineEndRegex_","blanklineStartRegex_","diff_cleanupSemanticScore_","one","two","char1","char2","nonAlphaNumeric1","nonAlphaNumeric2","whitespace1","whitespace2","lineBreak1","lineBreak2","blankLine1","blankLine2","equality1","edit","equality2","commonOffset","commonString","bestEquality1","bestEdit","bestEquality2","bestScore","score","fix_unicode","count_delete","count_insert","text_delete","text_insert","previous_equality","ends_with_pair_start","stray","k","starts_with_pair_end","n","charCode","str","remove_empty_tuples","tuples","ret","make_edit_splice","before","oldMiddle","newMiddle","after","oldText","newText","oldRange","newRange","oldLength","newLength","oldCursor","oldBefore","oldAfter","maybeNewCursor","editBefore","newCursor","newBefore","newAfter","oldPrefix","newPrefix","editAfter","cursor","oldSuffix","newSuffix","replaceRange","diff","require_lodash","__commonJSMin","exports","module","LARGE_ARRAY_SIZE","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reRegExpChar","reFlags","reIsHostCtor","reIsUint","cloneableTags","freeGlobal","freeSelf","root","freeExports","freeModule","moduleExports","addMapEntry","map","pair","addSetEntry","set","value","arrayEach","array","iteratee","index","length","arrayPush","values","offset","arrayReduce","accumulator","initAccum","baseTimes","n","result","getValue","object","key","isHostObject","mapToArray","overArg","func","transform","arg","setToArray","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","uid","funcToString","hasOwnProperty","objectToString","reIsNative","Buffer","Symbol","Uint8Array","getPrototype","objectCreate","propertyIsEnumerable","splice","nativeGetSymbols","nativeIsBuffer","nativeKeys","DataView","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","Hash","entries","entry","hashClear","hashDelete","hashGet","data","hashHas","hashSet","ListCache","listCacheClear","listCacheDelete","assocIndexOf","lastIndex","listCacheGet","listCacheHas","listCacheSet","MapCache","mapCacheClear","mapCacheDelete","getMapData","mapCacheGet","mapCacheHas","mapCacheSet","Stack","stackClear","stackDelete","stackGet","stackHas","stackSet","cache","pairs","arrayLikeKeys","inherited","isArray","isArguments","skipIndexes","isIndex","assignValue","objValue","eq","baseAssign","source","copyObject","keys","baseClone","isDeep","isFull","customizer","stack","isObject","isArr","initCloneArray","copyArray","tag","getTag","isFunc","isBuffer","cloneBuffer","initCloneObject","copySymbols","initCloneByTag","stacked","props","getAllKeys","subValue","baseCreate","proto","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","baseIsNative","isMasked","pattern","isFunction","baseKeys","isPrototype","buffer","cloneArrayBuffer","arrayBuffer","cloneDataView","dataView","cloneMap","cloneFunc","cloneRegExp","regexp","cloneSet","cloneSymbol","symbol","cloneTypedArray","typedArray","newValue","getSymbols","isKeyable","stubArray","Ctor","ctorString","type","cloneDeep","other","isArrayLikeObject","isArrayLike","isLength","isObjectLike","stubFalse","require_lodash","__commonJSMin","exports","module","LARGE_ARRAY_SIZE","HASH_UNDEFINED","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","MAX_SAFE_INTEGER","argsTag","arrayTag","asyncTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","nullTag","objectTag","promiseTag","proxyTag","regexpTag","setTag","stringTag","symbolTag","undefinedTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reRegExpChar","reIsHostCtor","reIsUint","typedArrayTags","freeGlobal","freeSelf","root","freeExports","freeModule","moduleExports","freeProcess","nodeUtil","nodeIsTypedArray","arrayFilter","array","predicate","index","length","resIndex","result","value","arrayPush","values","offset","arraySome","baseTimes","n","iteratee","baseUnary","func","cacheHas","cache","key","getValue","object","mapToArray","map","overArg","transform","arg","setToArray","set","arrayProto","funcProto","objectProto","coreJsData","funcToString","hasOwnProperty","maskSrcKey","uid","nativeObjectToString","reIsNative","Buffer","Symbol","Uint8Array","propertyIsEnumerable","splice","symToStringTag","nativeGetSymbols","nativeIsBuffer","nativeKeys","DataView","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","Hash","entries","entry","hashClear","hashDelete","hashGet","data","hashHas","hashSet","ListCache","listCacheClear","listCacheDelete","assocIndexOf","lastIndex","listCacheGet","listCacheHas","listCacheSet","MapCache","mapCacheClear","mapCacheDelete","getMapData","mapCacheGet","mapCacheHas","mapCacheSet","size","SetCache","setCacheAdd","setCacheHas","Stack","stackClear","stackDelete","stackGet","stackHas","stackSet","pairs","arrayLikeKeys","inherited","isArr","isArray","isArg","isArguments","isBuff","isBuffer","isType","isTypedArray","skipIndexes","isIndex","eq","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","getRawTag","objectToString","baseIsArguments","isObjectLike","baseIsEqual","other","bitmask","customizer","stack","baseIsEqualDeep","equalFunc","objIsArr","othIsArr","objTag","getTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","equalObjects","baseIsNative","isObject","isMasked","pattern","isFunction","baseIsTypedArray","isLength","baseKeys","isPrototype","isPartial","arrLength","othLength","stacked","seen","arrValue","othValue","compared","othIndex","tag","convert","objProps","getAllKeys","objLength","othProps","skipCtor","objValue","objCtor","othCtor","keys","getSymbols","isKeyable","isOwn","unmasked","symbol","stubArray","Ctor","ctorString","type","proto","isArrayLike","stubFalse","isEqual","cloneDeep","isEqual","AttributeMap","compose","a","b","keepNull","attributes","copy","key","diff","attrs","invert","attr","base","baseInverted","memo","transform","priority","exports","Op","length","op","exports","Op_1","Iterator","ops","length","nextOp","offset","opLength","retOp","op","index","next","rest","exports","diff","cloneDeep","isEqual","AttributeMap_1","exports","Op_1","OpIterator_1","NULL_CHARACTER","getEmbedTypeAndData","a","b","embedType","Delta","_Delta","ops","handler","arg","attributes","newOp","length","index","lastOp","predicate","passed","failed","op","initialValue","elem","start","end","iter","nextOp","other","thisIter","otherIter","firstOther","firstLeft","delta","thisOp","otherOp","action","thisData","otherData","rest","cursor","strings","prep","retDelta","diffResult","component","opLength","newline","line","base","inverted","baseIndex","baseOp","slice","opData","baseOpData","priority","transformedData","offset","nextType","module","cjsm","import_quill_delta","endpoint_default"],"sources":["../esm/npm/quill-delta@5.1.0/node_modules/fast-diff/diff.js","../esm/npm/quill-delta@5.1.0/node_modules/lodash.clonedeep/index.js","../esm/npm/quill-delta@5.1.0/node_modules/lodash.isequal/index.js","../esm/npm/quill-delta@5.1.0/node_modules/quill-delta/src/AttributeMap.ts","../esm/npm/quill-delta@5.1.0/node_modules/quill-delta/src/Op.ts","../esm/npm/quill-delta@5.1.0/node_modules/quill-delta/src/OpIterator.ts","../esm/npm/quill-delta@5.1.0/node_modules/quill-delta/src/Delta.ts","endpoint.js"],"sourcesContent":["/**\n * This library modifies the diff-patch-match library by Neil Fraser\n * by removing the patch and match functionality and certain advanced\n * options in the diff function. The original license is as follows:\n *\n * ===\n *\n * Diff Match and Patch\n *\n * Copyright 2006 Google Inc.\n * http://code.google.com/p/google-diff-match-patch/\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * 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 * 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 {Int|Object} [cursor_pos] Edit position in text1 or object with more info\n * @param {boolean} [cleanup] Apply semantic cleanup before returning.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_main(text1, text2, cursor_pos, cleanup, _fix_unicode) {\n  // Check for equality\n  if (text1 === text2) {\n    if (text1) {\n      return [[DIFF_EQUAL, text1]];\n    }\n    return [];\n  }\n\n  if (cursor_pos != null) {\n    var editdiff = find_cursor_edit_diff(text1, text2, cursor_pos);\n    if (editdiff) {\n      return editdiff;\n    }\n  }\n\n  // Trim off common prefix (speedup).\n  var commonlength = 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 = 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 = diff_compute_(text1, text2);\n\n  // Restore the prefix and suffix.\n  if (commonprefix) {\n    diffs.unshift([DIFF_EQUAL, commonprefix]);\n  }\n  if (commonsuffix) {\n    diffs.push([DIFF_EQUAL, commonsuffix]);\n  }\n  diff_cleanupMerge(diffs, _fix_unicode);\n  if (cleanup) {\n    diff_cleanupSemantic(diffs);\n  }\n  return diffs;\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 * @return {Array} Array of diff tuples.\n */\nfunction diff_compute_(text1, text2) {\n  var diffs;\n\n  if (!text1) {\n    // Just add some text (speedup).\n    return [[DIFF_INSERT, text2]];\n  }\n\n  if (!text2) {\n    // Just delete some text (speedup).\n    return [[DIFF_DELETE, text1]];\n  }\n\n  var longtext = text1.length \u003e text2.length ? text1 : text2;\n  var shorttext = text1.length \u003e 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 = [\n      [DIFF_INSERT, longtext.substring(0, i)],\n      [DIFF_EQUAL, shorttext],\n      [DIFF_INSERT, longtext.substring(i + shorttext.length)],\n    ];\n    // Swap insertions for deletions if diff is reversed.\n    if (text1.length \u003e 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 [\n      [DIFF_DELETE, text1],\n      [DIFF_INSERT, text2],\n    ];\n  }\n\n  // Check to see if the problem can be split in two.\n  var hm = 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 = diff_main(text1_a, text2_a);\n    var diffs_b = diff_main(text1_b, text2_b);\n    // Merge the results.\n    return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);\n  }\n\n  return diff_bisect_(text1, text2);\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 * @return {Array} Array of diff tuples.\n * @private\n */\nfunction diff_bisect_(text1, text2) {\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 \u0026 Firefox than mixing\n  // integers and undefined.\n  for (var x = 0; x \u003c 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 \u003c max_d; d++) {\n    // Walk the front path one step.\n    for (var k1 = -d + k1start; k1 \u003c= d - k1end; k1 += 2) {\n      var k1_offset = v_offset + k1;\n      var x1;\n      if (k1 === -d || (k1 !== d \u0026\u0026 v1[k1_offset - 1] \u003c 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 (\n        x1 \u003c text1_length \u0026\u0026\n        y1 \u003c text2_length \u0026\u0026\n        text1.charAt(x1) === text2.charAt(y1)\n      ) {\n        x1++;\n        y1++;\n      }\n      v1[k1_offset] = x1;\n      if (x1 \u003e text1_length) {\n        // Ran off the right of the graph.\n        k1end += 2;\n      } else if (y1 \u003e 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 \u003e= 0 \u0026\u0026 k2_offset \u003c v_length \u0026\u0026 v2[k2_offset] !== -1) {\n          // Mirror x2 onto top-left coordinate system.\n          var x2 = text1_length - v2[k2_offset];\n          if (x1 \u003e= x2) {\n            // Overlap detected.\n            return diff_bisectSplit_(text1, text2, x1, y1);\n          }\n        }\n      }\n    }\n\n    // Walk the reverse path one step.\n    for (var k2 = -d + k2start; k2 \u003c= d - k2end; k2 += 2) {\n      var k2_offset = v_offset + k2;\n      var x2;\n      if (k2 === -d || (k2 !== d \u0026\u0026 v2[k2_offset - 1] \u003c 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 (\n        x2 \u003c text1_length \u0026\u0026\n        y2 \u003c text2_length \u0026\u0026\n        text1.charAt(text1_length - x2 - 1) ===\n          text2.charAt(text2_length - y2 - 1)\n      ) {\n        x2++;\n        y2++;\n      }\n      v2[k2_offset] = x2;\n      if (x2 \u003e text1_length) {\n        // Ran off the left of the graph.\n        k2end += 2;\n      } else if (y2 \u003e 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 \u003e= 0 \u0026\u0026 k1_offset \u003c v_length \u0026\u0026 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 \u003e= x2) {\n            // Overlap detected.\n            return diff_bisectSplit_(text1, text2, x1, y1);\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 [\n    [DIFF_DELETE, text1],\n    [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 * @return {Array} Array of diff tuples.\n */\nfunction diff_bisectSplit_(text1, text2, x, y) {\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 = diff_main(text1a, text2a);\n  var diffsb = diff_main(text1b, text2b);\n\n  return diffs.concat(diffsb);\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 */\nfunction diff_commonPrefix(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerstart = 0;\n  while (pointermin \u003c pointermid) {\n    if (\n      text1.substring(pointerstart, pointermid) ==\n      text2.substring(pointerstart, pointermid)\n    ) {\n      pointermin = pointermid;\n      pointerstart = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n\n  if (is_surrogate_pair_start(text1.charCodeAt(pointermid - 1))) {\n    pointermid--;\n  }\n\n  return pointermid;\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 */\nfunction diff_commonOverlap_(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 \u003e text2_length) {\n    text1 = text1.substring(text1_length - text2_length);\n  } else if (text1_length \u003c text2_length) {\n    text2 = text2.substring(0, text1_length);\n  }\n  var text_length = Math.min(text1_length, text2_length);\n  // Quick check for the worst case.\n  if (text1 == text2) {\n    return text_length;\n  }\n\n  // Start by looking for a single character match\n  // and increase length until no match is found.\n  // Performance analysis: http://neil.fraser.name/news/2010/11/04/\n  var best = 0;\n  var length = 1;\n  while (true) {\n    var pattern = text1.substring(text_length - length);\n    var found = text2.indexOf(pattern);\n    if (found == -1) {\n      return best;\n    }\n    length += found;\n    if (\n      found == 0 ||\n      text1.substring(text_length - length) == text2.substring(0, length)\n    ) {\n      best = length;\n      length++;\n    }\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 */\nfunction diff_commonSuffix(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 || text1.slice(-1) !== text2.slice(-1)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerend = 0;\n  while (pointermin \u003c pointermid) {\n    if (\n      text1.substring(text1.length - pointermid, text1.length - pointerend) ==\n      text2.substring(text2.length - pointermid, text2.length - pointerend)\n    ) {\n      pointermin = pointermid;\n      pointerend = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n\n  if (is_surrogate_pair_end(text1.charCodeAt(text1.length - pointermid))) {\n    pointermid--;\n  }\n\n  return pointermid;\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.\u003cstring\u003e} 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 */\nfunction diff_halfMatch_(text1, text2) {\n  var longtext = text1.length \u003e text2.length ? text1 : text2;\n  var shorttext = text1.length \u003e text2.length ? text2 : text1;\n  if (longtext.length \u003c 4 || shorttext.length * 2 \u003c longtext.length) {\n    return null; // Pointless.\n  }\n\n  /**\n   * Does a substring of shorttext exist within longtext such that the substring\n   * is at least half the length of longtext?\n   * Closure, but does not reference any external 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.\u003cstring\u003e} 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 = diff_commonPrefix(\n        longtext.substring(i),\n        shorttext.substring(j)\n      );\n      var suffixLength = diff_commonSuffix(\n        longtext.substring(0, i),\n        shorttext.substring(0, j)\n      );\n      if (best_common.length \u003c suffixLength + prefixLength) {\n        best_common =\n          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 \u003e= longtext.length) {\n      return [\n        best_longtext_a,\n        best_longtext_b,\n        best_shorttext_a,\n        best_shorttext_b,\n        best_common,\n      ];\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_(\n    longtext,\n    shorttext,\n    Math.ceil(longtext.length / 4)\n  );\n  // Check again based on the third quarter.\n  var hm2 = diff_halfMatchI_(\n    longtext,\n    shorttext,\n    Math.ceil(longtext.length / 2)\n  );\n  var hm;\n  if (!hm1 \u0026\u0026 !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 \u003e 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 \u003e 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 * Reduce the number of edits by eliminating semantically trivial equalities.\n * @param {!Array.\u003c!diff_match_patch.Diff\u003e} diffs Array of diff tuples.\n */\nfunction diff_cleanupSemantic(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 \u003c diffs.length) {\n    if (diffs[pointer][0] == DIFF_EQUAL) {\n      // 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 {\n      // 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 (\n        lastequality \u0026\u0026\n        lastequality.length \u003c=\n          Math.max(length_insertions1, length_deletions1) \u0026\u0026\n        lastequality.length \u003c= Math.max(length_insertions2, length_deletions2)\n      ) {\n        // Duplicate record.\n        diffs.splice(equalities[equalitiesLength - 1], 0, [\n          DIFF_DELETE,\n          lastequality,\n        ]);\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 \u003e 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    diff_cleanupMerge(diffs);\n  }\n  diff_cleanupSemanticLossless(diffs);\n\n  // Find any overlaps between deletions and insertions.\n  // e.g: \u003cdel\u003eabcxxx\u003c/del\u003e\u003cins\u003exxxdef\u003c/ins\u003e\n  //   -\u003e \u003cdel\u003eabc\u003c/del\u003exxx\u003cins\u003edef\u003c/ins\u003e\n  // e.g: \u003cdel\u003exxxabc\u003c/del\u003e\u003cins\u003edefxxx\u003c/ins\u003e\n  //   -\u003e \u003cins\u003edef\u003c/ins\u003exxx\u003cdel\u003eabc\u003c/del\u003e\n  // Only extract an overlap if it is as big as the edit ahead or behind it.\n  pointer = 1;\n  while (pointer \u003c diffs.length) {\n    if (\n      diffs[pointer - 1][0] == DIFF_DELETE \u0026\u0026\n      diffs[pointer][0] == DIFF_INSERT\n    ) {\n      var deletion = diffs[pointer - 1][1];\n      var insertion = diffs[pointer][1];\n      var overlap_length1 = diff_commonOverlap_(deletion, insertion);\n      var overlap_length2 = diff_commonOverlap_(insertion, deletion);\n      if (overlap_length1 \u003e= overlap_length2) {\n        if (\n          overlap_length1 \u003e= deletion.length / 2 ||\n          overlap_length1 \u003e= insertion.length / 2\n        ) {\n          // Overlap found.  Insert an equality and trim the surrounding edits.\n          diffs.splice(pointer, 0, [\n            DIFF_EQUAL,\n            insertion.substring(0, overlap_length1),\n          ]);\n          diffs[pointer - 1][1] = deletion.substring(\n            0,\n            deletion.length - overlap_length1\n          );\n          diffs[pointer + 1][1] = insertion.substring(overlap_length1);\n          pointer++;\n        }\n      } else {\n        if (\n          overlap_length2 \u003e= deletion.length / 2 ||\n          overlap_length2 \u003e= insertion.length / 2\n        ) {\n          // Reverse overlap found.\n          // Insert an equality and swap and trim the surrounding edits.\n          diffs.splice(pointer, 0, [\n            DIFF_EQUAL,\n            deletion.substring(0, overlap_length2),\n          ]);\n          diffs[pointer - 1][0] = DIFF_INSERT;\n          diffs[pointer - 1][1] = insertion.substring(\n            0,\n            insertion.length - overlap_length2\n          );\n          diffs[pointer + 1][0] = DIFF_DELETE;\n          diffs[pointer + 1][1] = deletion.substring(overlap_length2);\n          pointer++;\n        }\n      }\n      pointer++;\n    }\n    pointer++;\n  }\n}\n\nvar nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\nvar whitespaceRegex_ = /\\s/;\nvar linebreakRegex_ = /[\\r\\n]/;\nvar blanklineEndRegex_ = /\\n\\r?\\n$/;\nvar blanklineStartRegex_ = /^\\r?\\n\\r?\\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\u003cins\u003eat c\u003c/ins\u003eame. -\u003e The \u003cins\u003ecat \u003c/ins\u003ecame.\n * @param {!Array.\u003c!diff_match_patch.Diff\u003e} diffs Array of diff tuples.\n */\nfunction diff_cleanupSemanticLossless(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(nonAlphaNumericRegex_);\n    var nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);\n    var whitespace1 = nonAlphaNumeric1 \u0026\u0026 char1.match(whitespaceRegex_);\n    var whitespace2 = nonAlphaNumeric2 \u0026\u0026 char2.match(whitespaceRegex_);\n    var lineBreak1 = whitespace1 \u0026\u0026 char1.match(linebreakRegex_);\n    var lineBreak2 = whitespace2 \u0026\u0026 char2.match(linebreakRegex_);\n    var blankLine1 = lineBreak1 \u0026\u0026 one.match(blanklineEndRegex_);\n    var blankLine2 = lineBreak2 \u0026\u0026 two.match(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 \u0026\u0026 !whitespace1 \u0026\u0026 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 \u003c diffs.length - 1) {\n    if (\n      diffs[pointer - 1][0] == DIFF_EQUAL \u0026\u0026\n      diffs[pointer + 1][0] == DIFF_EQUAL\n    ) {\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 = 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 =\n        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 =\n          diff_cleanupSemanticScore_(equality1, edit) +\n          diff_cleanupSemanticScore_(edit, equality2);\n        // The \u003e= encourages trailing rather than leading whitespace on edits.\n        if (score \u003e= bestScore) {\n          bestScore = score;\n          bestEquality1 = equality1;\n          bestEdit = edit;\n          bestEquality2 = equality2;\n        }\n      }\n\n      if (diffs[pointer - 1][1] != bestEquality1) {\n        // We have an improvement, save it back to the diff.\n        if (bestEquality1) {\n          diffs[pointer - 1][1] = bestEquality1;\n        } else {\n          diffs.splice(pointer - 1, 1);\n          pointer--;\n        }\n        diffs[pointer][1] = bestEdit;\n        if (bestEquality2) {\n          diffs[pointer + 1][1] = bestEquality2;\n        } else {\n          diffs.splice(pointer + 1, 1);\n          pointer--;\n        }\n      }\n    }\n    pointer++;\n  }\n}\n\n/**\n * Reorder and merge like edit sections.  Merge equalities.\n * Any edit section can move as long as it doesn't cross an equality.\n * @param {Array} diffs Array of diff tuples.\n * @param {boolean} fix_unicode Whether to normalize to a unicode-correct diff\n */\nfunction diff_cleanupMerge(diffs, fix_unicode) {\n  diffs.push([DIFF_EQUAL, \"\"]); // Add a dummy entry at the end.\n  var pointer = 0;\n  var count_delete = 0;\n  var count_insert = 0;\n  var text_delete = \"\";\n  var text_insert = \"\";\n  var commonlength;\n  while (pointer \u003c diffs.length) {\n    if (pointer \u003c diffs.length - 1 \u0026\u0026 !diffs[pointer][1]) {\n      diffs.splice(pointer, 1);\n      continue;\n    }\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        var previous_equality = pointer - count_insert - count_delete - 1;\n        if (fix_unicode) {\n          // prevent splitting of unicode surrogate pairs.  when fix_unicode is true,\n          // we assume that the old and new text in the diff are complete and correct\n          // unicode-encoded JS strings, but the tuple boundaries may fall between\n          // surrogate pairs.  we fix this by shaving off stray surrogates from the end\n          // of the previous equality and the beginning of this equality.  this may create\n          // empty equalities or a common prefix or suffix.  for example, if AB and AC are\n          // emojis, `[[0, 'A'], [-1, 'BA'], [0, 'C']]` would turn into deleting 'ABAC' and\n          // inserting 'AC', and then the common suffix 'AC' will be eliminated.  in this\n          // particular case, both equalities go away, we absorb any previous inequalities,\n          // and we keep scanning for the next equality before rewriting the tuples.\n          if (\n            previous_equality \u003e= 0 \u0026\u0026\n            ends_with_pair_start(diffs[previous_equality][1])\n          ) {\n            var stray = diffs[previous_equality][1].slice(-1);\n            diffs[previous_equality][1] = diffs[previous_equality][1].slice(\n              0,\n              -1\n            );\n            text_delete = stray + text_delete;\n            text_insert = stray + text_insert;\n            if (!diffs[previous_equality][1]) {\n              // emptied out previous equality, so delete it and include previous delete/insert\n              diffs.splice(previous_equality, 1);\n              pointer--;\n              var k = previous_equality - 1;\n              if (diffs[k] \u0026\u0026 diffs[k][0] === DIFF_INSERT) {\n                count_insert++;\n                text_insert = diffs[k][1] + text_insert;\n                k--;\n              }\n              if (diffs[k] \u0026\u0026 diffs[k][0] === DIFF_DELETE) {\n                count_delete++;\n                text_delete = diffs[k][1] + text_delete;\n                k--;\n              }\n              previous_equality = k;\n            }\n          }\n          if (starts_with_pair_end(diffs[pointer][1])) {\n            var stray = diffs[pointer][1].charAt(0);\n            diffs[pointer][1] = diffs[pointer][1].slice(1);\n            text_delete += stray;\n            text_insert += stray;\n          }\n        }\n        if (pointer \u003c diffs.length - 1 \u0026\u0026 !diffs[pointer][1]) {\n          // for empty equality not at end, wait for next equality\n          diffs.splice(pointer, 1);\n          break;\n        }\n        if (text_delete.length \u003e 0 || text_insert.length \u003e 0) {\n          // note that diff_commonPrefix and diff_commonSuffix are unicode-aware\n          if (text_delete.length \u003e 0 \u0026\u0026 text_insert.length \u003e 0) {\n            // Factor out any common prefixes.\n            commonlength = diff_commonPrefix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              if (previous_equality \u003e= 0) {\n                diffs[previous_equality][1] += text_insert.substring(\n                  0,\n                  commonlength\n                );\n              } else {\n                diffs.splice(0, 0, [\n                  DIFF_EQUAL,\n                  text_insert.substring(0, commonlength),\n                ]);\n                pointer++;\n              }\n              text_insert = text_insert.substring(commonlength);\n              text_delete = text_delete.substring(commonlength);\n            }\n            // Factor out any common suffixes.\n            commonlength = diff_commonSuffix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              diffs[pointer][1] =\n                text_insert.substring(text_insert.length - commonlength) +\n                diffs[pointer][1];\n              text_insert = text_insert.substring(\n                0,\n                text_insert.length - commonlength\n              );\n              text_delete = text_delete.substring(\n                0,\n                text_delete.length - commonlength\n              );\n            }\n          }\n          // Delete the offending records and add the merged ones.\n          var n = count_insert + count_delete;\n          if (text_delete.length === 0 \u0026\u0026 text_insert.length === 0) {\n            diffs.splice(pointer - n, n);\n            pointer = pointer - n;\n          } else if (text_delete.length === 0) {\n            diffs.splice(pointer - n, n, [DIFF_INSERT, text_insert]);\n            pointer = pointer - n + 1;\n          } else if (text_insert.length === 0) {\n            diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete]);\n            pointer = pointer - n + 1;\n          } else {\n            diffs.splice(\n              pointer - n,\n              n,\n              [DIFF_DELETE, text_delete],\n              [DIFF_INSERT, text_insert]\n            );\n            pointer = pointer - n + 2;\n          }\n        }\n        if (pointer !== 0 \u0026\u0026 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\u003cins\u003eBA\u003c/ins\u003eC -\u003e \u003cins\u003eAB\u003c/ins\u003eAC\n  var changes = false;\n  pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer \u003c diffs.length - 1) {\n    if (\n      diffs[pointer - 1][0] === DIFF_EQUAL \u0026\u0026\n      diffs[pointer + 1][0] === DIFF_EQUAL\n    ) {\n      // This is a single edit surrounded by equalities.\n      if (\n        diffs[pointer][1].substring(\n          diffs[pointer][1].length - diffs[pointer - 1][1].length\n        ) === diffs[pointer - 1][1]\n      ) {\n        // Shift the edit over the previous equality.\n        diffs[pointer][1] =\n          diffs[pointer - 1][1] +\n          diffs[pointer][1].substring(\n            0,\n            diffs[pointer][1].length - diffs[pointer - 1][1].length\n          );\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 (\n        diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n        diffs[pointer + 1][1]\n      ) {\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    diff_cleanupMerge(diffs, fix_unicode);\n  }\n}\n\nfunction is_surrogate_pair_start(charCode) {\n  return charCode \u003e= 0xd800 \u0026\u0026 charCode \u003c= 0xdbff;\n}\n\nfunction is_surrogate_pair_end(charCode) {\n  return charCode \u003e= 0xdc00 \u0026\u0026 charCode \u003c= 0xdfff;\n}\n\nfunction starts_with_pair_end(str) {\n  return is_surrogate_pair_end(str.charCodeAt(0));\n}\n\nfunction ends_with_pair_start(str) {\n  return is_surrogate_pair_start(str.charCodeAt(str.length - 1));\n}\n\nfunction remove_empty_tuples(tuples) {\n  var ret = [];\n  for (var i = 0; i \u003c tuples.length; i++) {\n    if (tuples[i][1].length \u003e 0) {\n      ret.push(tuples[i]);\n    }\n  }\n  return ret;\n}\n\nfunction make_edit_splice(before, oldMiddle, newMiddle, after) {\n  if (ends_with_pair_start(before) || starts_with_pair_end(after)) {\n    return null;\n  }\n  return remove_empty_tuples([\n    [DIFF_EQUAL, before],\n    [DIFF_DELETE, oldMiddle],\n    [DIFF_INSERT, newMiddle],\n    [DIFF_EQUAL, after],\n  ]);\n}\n\nfunction find_cursor_edit_diff(oldText, newText, cursor_pos) {\n  // note: this runs after equality check has ruled out exact equality\n  var oldRange =\n    typeof cursor_pos === \"number\"\n      ? { index: cursor_pos, length: 0 }\n      : cursor_pos.oldRange;\n  var newRange = typeof cursor_pos === \"number\" ? null : cursor_pos.newRange;\n  // take into account the old and new selection to generate the best diff\n  // possible for a text edit.  for example, a text change from \"xxx\" to \"xx\"\n  // could be a delete or forwards-delete of any one of the x's, or the\n  // result of selecting two of the x's and typing \"x\".\n  var oldLength = oldText.length;\n  var newLength = newText.length;\n  if (oldRange.length === 0 \u0026\u0026 (newRange === null || newRange.length === 0)) {\n    // see if we have an insert or delete before or after cursor\n    var oldCursor = oldRange.index;\n    var oldBefore = oldText.slice(0, oldCursor);\n    var oldAfter = oldText.slice(oldCursor);\n    var maybeNewCursor = newRange ? newRange.index : null;\n    editBefore: {\n      // is this an insert or delete right before oldCursor?\n      var newCursor = oldCursor + newLength - oldLength;\n      if (maybeNewCursor !== null \u0026\u0026 maybeNewCursor !== newCursor) {\n        break editBefore;\n      }\n      if (newCursor \u003c 0 || newCursor \u003e newLength) {\n        break editBefore;\n      }\n      var newBefore = newText.slice(0, newCursor);\n      var newAfter = newText.slice(newCursor);\n      if (newAfter !== oldAfter) {\n        break editBefore;\n      }\n      var prefixLength = Math.min(oldCursor, newCursor);\n      var oldPrefix = oldBefore.slice(0, prefixLength);\n      var newPrefix = newBefore.slice(0, prefixLength);\n      if (oldPrefix !== newPrefix) {\n        break editBefore;\n      }\n      var oldMiddle = oldBefore.slice(prefixLength);\n      var newMiddle = newBefore.slice(prefixLength);\n      return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldAfter);\n    }\n    editAfter: {\n      // is this an insert or delete right after oldCursor?\n      if (maybeNewCursor !== null \u0026\u0026 maybeNewCursor !== oldCursor) {\n        break editAfter;\n      }\n      var cursor = oldCursor;\n      var newBefore = newText.slice(0, cursor);\n      var newAfter = newText.slice(cursor);\n      if (newBefore !== oldBefore) {\n        break editAfter;\n      }\n      var suffixLength = Math.min(oldLength - cursor, newLength - cursor);\n      var oldSuffix = oldAfter.slice(oldAfter.length - suffixLength);\n      var newSuffix = newAfter.slice(newAfter.length - suffixLength);\n      if (oldSuffix !== newSuffix) {\n        break editAfter;\n      }\n      var oldMiddle = oldAfter.slice(0, oldAfter.length - suffixLength);\n      var newMiddle = newAfter.slice(0, newAfter.length - suffixLength);\n      return make_edit_splice(oldBefore, oldMiddle, newMiddle, oldSuffix);\n    }\n  }\n  if (oldRange.length \u003e 0 \u0026\u0026 newRange \u0026\u0026 newRange.length === 0) {\n    replaceRange: {\n      // see if diff could be a splice of the old selection range\n      var oldPrefix = oldText.slice(0, oldRange.index);\n      var oldSuffix = oldText.slice(oldRange.index + oldRange.length);\n      var prefixLength = oldPrefix.length;\n      var suffixLength = oldSuffix.length;\n      if (newLength \u003c prefixLength + suffixLength) {\n        break replaceRange;\n      }\n      var newPrefix = newText.slice(0, prefixLength);\n      var newSuffix = newText.slice(newLength - suffixLength);\n      if (oldPrefix !== newPrefix || oldSuffix !== newSuffix) {\n        break replaceRange;\n      }\n      var oldMiddle = oldText.slice(prefixLength, oldLength - suffixLength);\n      var newMiddle = newText.slice(prefixLength, newLength - suffixLength);\n      return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldSuffix);\n    }\n  }\n\n  return null;\n}\n\nfunction diff(text1, text2, cursor_pos, cleanup) {\n  // only pass fix_unicode=true at the top level, not when diff_main is\n  // recursively invoked\n  return diff_main(text1, text2, cursor_pos, cleanup, true);\n}\n\ndiff.INSERT = DIFF_INSERT;\ndiff.DELETE = DIFF_DELETE;\ndiff.EQUAL = DIFF_EQUAL;\n\nmodule.exports = diff;\n","/**\n * lodash (Custom Build) \u003chttps://lodash.com/\u003e\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors \u003chttps://jquery.org/\u003e\n * Released under MIT license \u003chttps://lodash.com/license\u003e\n * Based on Underscore.js 1.8.3 \u003chttp://underscorejs.org/LICENSE\u003e\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters \u0026 Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' \u0026\u0026 global \u0026\u0026 global.Object === Object \u0026\u0026 global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' \u0026\u0026 self \u0026\u0026 self.Object === Object \u0026\u0026 self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' \u0026\u0026 exports \u0026\u0026 !exports.nodeType \u0026\u0026 exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports \u0026\u0026 typeof module == 'object' \u0026\u0026 module \u0026\u0026 !module.nodeType \u0026\u0026 module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule \u0026\u0026 freeModule.exports === freeExports;\n\n/**\n * Adds the key-value `pair` to `map`.\n *\n * @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n */\nfunction addMapEntry(map, pair) {\n  // Don't return `map.set` because it's not chainable in IE 11.\n  map.set(pair[0], pair[1]);\n  return map;\n}\n\n/**\n * Adds `value` to `set`.\n *\n * @private\n * @param {Object} set The set to modify.\n * @param {*} value The value to add.\n * @returns {Object} Returns `set`.\n */\nfunction addSetEntry(set, value) {\n  // Don't return `set.add` because it's not chainable in IE 11.\n  set.add(value);\n  return set;\n}\n\n/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  while (++index \u003c length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index \u003c length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n *  the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  if (initAccum \u0026\u0026 length) {\n    accumulator = array[++index];\n  }\n  while (++index \u003c length) {\n    accumulator = iteratee(accumulator, array[index], index, array);\n  }\n  return accumulator;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index \u003c n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Checks if `value` is a host object in IE \u003c 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n  if (value != null \u0026\u0026 typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\n  }\n  return result;\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData \u0026\u0026 coreJsData.keys \u0026\u0026 coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$\u0026')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index \u003c length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  return this.has(key) \u0026\u0026 delete this.__data__[key];\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  data[key] = (nativeCreate \u0026\u0026 value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index \u003c length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index \u003c 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index \u003c 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) \u003e -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index \u003c 0) {\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index \u003c length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  return getMapData(this, key)['delete'](key);\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  getMapData(this, key).set(key, value);\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  this.__data__ = new ListCache(entries);\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  return this.__data__['delete'](key);\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var cache = this.__data__;\n  if (cache instanceof ListCache) {\n    var pairs = cache.__data__;\n    if (!Map || (pairs.length \u003c LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      return this;\n    }\n    cache = this.__data__ = new MapCache(pairs);\n  }\n  cache.set(key, value);\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) \u0026\u0026\n        !(skipIndexes \u0026\u0026 (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) \u0026\u0026 eq(objValue, value)) ||\n      (value === undefined \u0026\u0026 !(key in object))) {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object \u0026\u0026 copyObject(source, keys(source), object);\n}\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n  var result;\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc \u0026\u0026 !object)) {\n      if (isHostObject(value)) {\n        return object ? value : {};\n      }\n      result = initCloneObject(isFunc ? {} : value);\n      if (!isDeep) {\n        return copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, baseClone, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (!isArr) {\n    var props = isFull ? getAllKeys(value) : keys(value);\n  }\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n  });\n  return result;\n}\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nfunction baseCreate(proto) {\n  return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  return objectToString.call(value);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) \u0026\u0026 key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var result = new buffer.constructor(buffer.length);\n  buffer.copy(result);\n  return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/**\n * Creates a clone of `map`.\n *\n * @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n */\nfunction cloneMap(map, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n  return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\n/**\n * Creates a clone of `set`.\n *\n * @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n */\nfunction cloneSet(set, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n  return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index \u003c length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index \u003c length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    assignValue(object, key, newValue === undefined ? source[key] : newValue);\n  }\n  return object;\n}\n\n/**\n * Copies own symbol properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * Creates an array of the own enumerable symbol properties of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge \u003c 14, and promises in Node.js.\nif ((DataView \u0026\u0026 getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map \u0026\u0026 getTag(new Map) != mapTag) ||\n    (Promise \u0026\u0026 getTag(Promise.resolve()) != promiseTag) ||\n    (Set \u0026\u0026 getTag(new Set) != setTag) ||\n    (WeakMap \u0026\u0026 getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = objectToString.call(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : undefined;\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length \u0026\u0026 typeof array[0] == 'string' \u0026\u0026 hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' \u0026\u0026 !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return cloneMap(object, isDeep, cloneFunc);\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return cloneSet(object, isDeep, cloneFunc);\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length \u0026\u0026\n    (typeof value == 'number' || reIsUint.test(value)) \u0026\u0026\n    (value \u003e -1 \u0026\u0026 value % 1 == 0 \u0026\u0026 value \u003c length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey \u0026\u0026 (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value \u0026\u0026 value.constructor,\n      proto = (typeof Ctor == 'function' \u0026\u0026 Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // =\u003e false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, true, true);\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // =\u003e true\n *\n * _.eq(object, other);\n * // =\u003e false\n *\n * _.eq('a', 'a');\n * // =\u003e true\n *\n * _.eq('a', Object('a'));\n * // =\u003e false\n *\n * _.eq(NaN, NaN);\n * // =\u003e true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value \u0026\u0026 other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // =\u003e true\n *\n * _.isArguments([1, 2, 3]);\n * // =\u003e false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) \u0026\u0026 hasOwnProperty.call(value, 'callee') \u0026\u0026\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // =\u003e true\n *\n * _.isArray(document.body.children);\n * // =\u003e false\n *\n * _.isArray('abc');\n * // =\u003e false\n *\n * _.isArray(_.noop);\n * // =\u003e false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // =\u003e true\n *\n * _.isArrayLike(document.body.children);\n * // =\u003e true\n *\n * _.isArrayLike('abc');\n * // =\u003e true\n *\n * _.isArrayLike(_.noop);\n * // =\u003e false\n */\nfunction isArrayLike(value) {\n  return value != null \u0026\u0026 isLength(value.length) \u0026\u0026 !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // =\u003e true\n *\n * _.isArrayLikeObject(document.body.children);\n * // =\u003e true\n *\n * _.isArrayLikeObject('abc');\n * // =\u003e false\n *\n * _.isArrayLikeObject(_.noop);\n * // =\u003e false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) \u0026\u0026 isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // =\u003e true\n *\n * _.isBuffer(new Uint8Array(2));\n * // =\u003e false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // =\u003e true\n *\n * _.isFunction(/abc/);\n * // =\u003e false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // =\u003e true\n *\n * _.isLength(Number.MIN_VALUE);\n * // =\u003e false\n *\n * _.isLength(Infinity);\n * // =\u003e false\n *\n * _.isLength('3');\n * // =\u003e false\n */\nfunction isLength(value) {\n  return typeof value == 'number' \u0026\u0026\n    value \u003e -1 \u0026\u0026 value % 1 == 0 \u0026\u0026 value \u003c= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // =\u003e true\n *\n * _.isObject([1, 2, 3]);\n * // =\u003e true\n *\n * _.isObject(_.noop);\n * // =\u003e true\n *\n * _.isObject(null);\n * // =\u003e false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value \u0026\u0026 (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // =\u003e true\n *\n * _.isObjectLike([1, 2, 3]);\n * // =\u003e true\n *\n * _.isObjectLike(_.noop);\n * // =\u003e false\n *\n * _.isObjectLike(null);\n * // =\u003e false\n */\nfunction isObjectLike(value) {\n  return !!value \u0026\u0026 typeof value == 'object';\n}\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // =\u003e ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // =\u003e ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // =\u003e [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // =\u003e false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // =\u003e [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = cloneDeep;\n","/**\n * Lodash (Custom Build) \u003chttps://lodash.com/\u003e\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors \u003chttps://js.foundation/\u003e\n * Released under MIT license \u003chttps://lodash.com/license\u003e\n * Based on Underscore.js 1.8.3 \u003chttp://underscorejs.org/LICENSE\u003e\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters \u0026 Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    asyncTag = '[object AsyncFunction]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    nullTag = '[object Null]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' \u0026\u0026 global \u0026\u0026 global.Object === Object \u0026\u0026 global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' \u0026\u0026 self \u0026\u0026 self.Object === Object \u0026\u0026 self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' \u0026\u0026 exports \u0026\u0026 !exports.nodeType \u0026\u0026 exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports \u0026\u0026 typeof module == 'object' \u0026\u0026 module \u0026\u0026 !module.nodeType \u0026\u0026 module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule \u0026\u0026 freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports \u0026\u0026 freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    return freeProcess \u0026\u0026 freeProcess.binding \u0026\u0026 freeProcess.binding('util');\n  } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil \u0026\u0026 nodeUtil.isTypedArray;\n\n/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index \u003c length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index \u003c length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index \u003c length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index \u003c n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\n/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData \u0026\u0026 coreJsData.keys \u0026\u0026 coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$\u0026')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index \u003c length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) \u0026\u0026 delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate \u0026\u0026 value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index \u003c length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index \u003c 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index \u003c 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) \u003e -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index \u003c 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index \u003c length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index \u003c length) {\n    this.add(values[index]);\n  }\n}\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\n/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length \u003c LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr \u0026\u0026 isArguments(value),\n      isBuff = !isArr \u0026\u0026 !isArg \u0026\u0026 isBuffer(value),\n      isType = !isArr \u0026\u0026 !isArg \u0026\u0026 !isBuff \u0026\u0026 isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) \u0026\u0026\n        !(skipIndexes \u0026\u0026 (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff \u0026\u0026 (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType \u0026\u0026 (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag \u0026\u0026 symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) \u0026\u0026 baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) \u0026\u0026 !isObjectLike(other))) {\n    return value !== value \u0026\u0026 other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag \u0026\u0026 isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag \u0026\u0026 !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask \u0026 COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj \u0026\u0026 hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj \u0026\u0026 hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) \u0026\u0026\n    isLength(value.length) \u0026\u0026 !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) \u0026\u0026 key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask \u0026 COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength \u0026\u0026 !(isPartial \u0026\u0026 othLength \u003e arrLength)) {\n    return false;\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(array);\n  if (stacked \u0026\u0026 stack.get(other)) {\n    return stacked == other;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask \u0026 COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index \u003c arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) \u0026\u0026\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name \u0026\u0026 object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask \u0026 COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size \u0026\u0026 !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask \u0026 COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength \u0026\u0026 !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(object);\n  if (stacked \u0026\u0026 stack.get(other)) {\n    return stacked == other;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index \u003c objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result \u0026\u0026 !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor \u0026\u0026\n        ('constructor' in object \u0026\u0026 'constructor' in other) \u0026\u0026\n        !(typeof objCtor == 'function' \u0026\u0026 objCtor instanceof objCtor \u0026\u0026\n          typeof othCtor == 'function' \u0026\u0026 othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js \u003c 6.\nif ((DataView \u0026\u0026 getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map \u0026\u0026 getTag(new Map) != mapTag) ||\n    (Promise \u0026\u0026 getTag(Promise.resolve()) != promiseTag) ||\n    (Set \u0026\u0026 getTag(new Set) != setTag) ||\n    (WeakMap \u0026\u0026 getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length \u0026\u0026\n    (typeof value == 'number' || reIsUint.test(value)) \u0026\u0026\n    (value \u003e -1 \u0026\u0026 value % 1 == 0 \u0026\u0026 value \u003c length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey \u0026\u0026 (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value \u0026\u0026 value.constructor,\n      proto = (typeof Ctor == 'function' \u0026\u0026 Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // =\u003e true\n *\n * _.eq(object, other);\n * // =\u003e false\n *\n * _.eq('a', 'a');\n * // =\u003e true\n *\n * _.eq('a', Object('a'));\n * // =\u003e false\n *\n * _.eq(NaN, NaN);\n * // =\u003e true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value \u0026\u0026 other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // =\u003e true\n *\n * _.isArguments([1, 2, 3]);\n * // =\u003e false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) \u0026\u0026 hasOwnProperty.call(value, 'callee') \u0026\u0026\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // =\u003e true\n *\n * _.isArray(document.body.children);\n * // =\u003e false\n *\n * _.isArray('abc');\n * // =\u003e false\n *\n * _.isArray(_.noop);\n * // =\u003e false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // =\u003e true\n *\n * _.isArrayLike(document.body.children);\n * // =\u003e true\n *\n * _.isArrayLike('abc');\n * // =\u003e true\n *\n * _.isArrayLike(_.noop);\n * // =\u003e false\n */\nfunction isArrayLike(value) {\n  return value != null \u0026\u0026 isLength(value.length) \u0026\u0026 !isFunction(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // =\u003e true\n *\n * _.isBuffer(new Uint8Array(2));\n * // =\u003e false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // =\u003e true\n *\n * object === other;\n * // =\u003e false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // =\u003e true\n *\n * _.isFunction(/abc/);\n * // =\u003e false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // =\u003e true\n *\n * _.isLength(Number.MIN_VALUE);\n * // =\u003e false\n *\n * _.isLength(Infinity);\n * // =\u003e false\n *\n * _.isLength('3');\n * // =\u003e false\n */\nfunction isLength(value) {\n  return typeof value == 'number' \u0026\u0026\n    value \u003e -1 \u0026\u0026 value % 1 == 0 \u0026\u0026 value \u003c= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // =\u003e true\n *\n * _.isObject([1, 2, 3]);\n * // =\u003e true\n *\n * _.isObject(_.noop);\n * // =\u003e true\n *\n * _.isObject(null);\n * // =\u003e false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null \u0026\u0026 (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // =\u003e true\n *\n * _.isObjectLike([1, 2, 3]);\n * // =\u003e true\n *\n * _.isObjectLike(_.noop);\n * // =\u003e false\n *\n * _.isObjectLike(null);\n * // =\u003e false\n */\nfunction isObjectLike(value) {\n  return value != null \u0026\u0026 typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // =\u003e true\n *\n * _.isTypedArray([]);\n * // =\u003e false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // =\u003e ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // =\u003e ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // =\u003e [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // =\u003e false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // =\u003e [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = isEqual;\n","import cloneDeep = require('lodash.clonedeep');\nimport isEqual = require('lodash.isequal');\n\ninterface AttributeMap {\n  [key: string]: unknown;\n}\n\nnamespace AttributeMap {\n  export function compose(\n    a: AttributeMap = {},\n    b: AttributeMap = {},\n    keepNull = false,\n  ): AttributeMap | undefined {\n    if (typeof a !== 'object') {\n      a = {};\n    }\n    if (typeof b !== 'object') {\n      b = {};\n    }\n    let attributes = cloneDeep(b);\n    if (!keepNull) {\n      attributes = Object.keys(attributes).reduce\u003cAttributeMap\u003e((copy, key) =\u003e {\n        if (attributes[key] != null) {\n          copy[key] = attributes[key];\n        }\n        return copy;\n      }, {});\n    }\n    for (const key in a) {\n      if (a[key] !== undefined \u0026\u0026 b[key] === undefined) {\n        attributes[key] = a[key];\n      }\n    }\n    return Object.keys(attributes).length \u003e 0 ? attributes : undefined;\n  }\n\n  export function diff(\n    a: AttributeMap = {},\n    b: AttributeMap = {},\n  ): AttributeMap | undefined {\n    if (typeof a !== 'object') {\n      a = {};\n    }\n    if (typeof b !== 'object') {\n      b = {};\n    }\n    const attributes = Object.keys(a)\n      .concat(Object.keys(b))\n      .reduce\u003cAttributeMap\u003e((attrs, key) =\u003e {\n        if (!isEqual(a[key], b[key])) {\n          attrs[key] = b[key] === undefined ? null : b[key];\n        }\n        return attrs;\n      }, {});\n    return Object.keys(attributes).length \u003e 0 ? attributes : undefined;\n  }\n\n  export function invert(\n    attr: AttributeMap = {},\n    base: AttributeMap = {},\n  ): AttributeMap {\n    attr = attr || {};\n    const baseInverted = Object.keys(base).reduce\u003cAttributeMap\u003e((memo, key) =\u003e {\n      if (base[key] !== attr[key] \u0026\u0026 attr[key] !== undefined) {\n        memo[key] = base[key];\n      }\n      return memo;\n    }, {});\n    return Object.keys(attr).reduce\u003cAttributeMap\u003e((memo, key) =\u003e {\n      if (attr[key] !== base[key] \u0026\u0026 base[key] === undefined) {\n        memo[key] = null;\n      }\n      return memo;\n    }, baseInverted);\n  }\n\n  export function transform(\n    a: AttributeMap | undefined,\n    b: AttributeMap | undefined,\n    priority = false,\n  ): AttributeMap | undefined {\n    if (typeof a !== 'object') {\n      return b;\n    }\n    if (typeof b !== 'object') {\n      return undefined;\n    }\n    if (!priority) {\n      return b; // b simply overwrites us without priority\n    }\n    const attributes = Object.keys(b).reduce\u003cAttributeMap\u003e((attrs, key) =\u003e {\n      if (a[key] === undefined) {\n        attrs[key] = b[key]; // null is a valid value\n      }\n      return attrs;\n    }, {});\n    return Object.keys(attributes).length \u003e 0 ? attributes : undefined;\n  }\n}\n\nexport default AttributeMap;\n","import AttributeMap from './AttributeMap';\n\ninterface Op {\n  // only one property out of {insert, delete, retain} will be present\n  insert?: string | Record\u003cstring, unknown\u003e;\n  delete?: number;\n  retain?: number | Record\u003cstring, unknown\u003e;\n\n  attributes?: AttributeMap;\n}\n\nnamespace Op {\n  export function length(op: Op): number {\n    if (typeof op.delete === 'number') {\n      return op.delete;\n    } else if (typeof op.retain === 'number') {\n      return op.retain;\n    } else if (typeof op.retain === 'object' \u0026\u0026 op.retain !== null) {\n      return 1;\n    } else {\n      return typeof op.insert === 'string' ? op.insert.length : 1;\n    }\n  }\n}\n\nexport default Op;\n","import Op from './Op';\n\nexport default class Iterator {\n  ops: Op[];\n  index: number;\n  offset: number;\n\n  constructor(ops: Op[]) {\n    this.ops = ops;\n    this.index = 0;\n    this.offset = 0;\n  }\n\n  hasNext(): boolean {\n    return this.peekLength() \u003c Infinity;\n  }\n\n  next(length?: number): Op {\n    if (!length) {\n      length = Infinity;\n    }\n    const nextOp = this.ops[this.index];\n    if (nextOp) {\n      const offset = this.offset;\n      const opLength = Op.length(nextOp);\n      if (length \u003e= opLength - offset) {\n        length = opLength - offset;\n        this.index += 1;\n        this.offset = 0;\n      } else {\n        this.offset += length;\n      }\n      if (typeof nextOp.delete === 'number') {\n        return { delete: length };\n      } else {\n        const retOp: Op = {};\n        if (nextOp.attributes) {\n          retOp.attributes = nextOp.attributes;\n        }\n        if (typeof nextOp.retain === 'number') {\n          retOp.retain = length;\n        } else if (\n          typeof nextOp.retain === 'object' \u0026\u0026\n          nextOp.retain !== null\n        ) {\n          // offset should === 0, length should === 1\n          retOp.retain = nextOp.retain;\n        } else if (typeof nextOp.insert === 'string') {\n          retOp.insert = nextOp.insert.substr(offset, length);\n        } else {\n          // offset should === 0, length should === 1\n          retOp.insert = nextOp.insert;\n        }\n        return retOp;\n      }\n    } else {\n      return { retain: Infinity };\n    }\n  }\n\n  peek(): Op {\n    return this.ops[this.index];\n  }\n\n  peekLength(): number {\n    if (this.ops[this.index]) {\n      // Should never return 0 if our index is being managed correctly\n      return Op.length(this.ops[this.index]) - this.offset;\n    } else {\n      return Infinity;\n    }\n  }\n\n  peekType(): string {\n    const op = this.ops[this.index];\n    if (op) {\n      if (typeof op.delete === 'number') {\n        return 'delete';\n      } else if (\n        typeof op.retain === 'number' ||\n        (typeof op.retain === 'object' \u0026\u0026 op.retain !== null)\n      ) {\n        return 'retain';\n      } else {\n        return 'insert';\n      }\n    }\n    return 'retain';\n  }\n\n  rest(): Op[] {\n    if (!this.hasNext()) {\n      return [];\n    } else if (this.offset === 0) {\n      return this.ops.slice(this.index);\n    } else {\n      const offset = this.offset;\n      const index = this.index;\n      const next = this.next();\n      const rest = this.ops.slice(this.index);\n      this.offset = offset;\n      this.index = index;\n      return [next].concat(rest);\n    }\n  }\n}\n","import * as diff from 'fast-diff';\nimport cloneDeep = require('lodash.clonedeep');\nimport isEqual = require('lodash.isequal');\nimport AttributeMap from './AttributeMap';\nimport Op from './Op';\nimport OpIterator from './OpIterator';\n\nconst NULL_CHARACTER = String.fromCharCode(0); // Placeholder char for embed in diff()\n\ninterface EmbedHandler\u003cT\u003e {\n  compose(a: T, b: T, keepNull: boolean): T;\n  invert(a: T, b: T): T;\n  transform(a: T, b: T, priority: boolean): T;\n}\n\nconst getEmbedTypeAndData = (\n  a: Op['insert'] | Op['retain'],\n  b: Op['insert'],\n): [string, unknown, unknown] =\u003e {\n  if (typeof a !== 'object' || a === null) {\n    throw new Error(`cannot retain a ${typeof a}`);\n  }\n  if (typeof b !== 'object' || b === null) {\n    throw new Error(`cannot retain a ${typeof b}`);\n  }\n  const embedType = Object.keys(a)[0];\n  if (!embedType || embedType !== Object.keys(b)[0]) {\n    throw new Error(\n      `embed types not matched: ${embedType} != ${Object.keys(b)[0]}`,\n    );\n  }\n  return [embedType, a[embedType], b[embedType]];\n};\n\nclass Delta {\n  static Op = Op;\n  static OpIterator = OpIterator;\n  static AttributeMap = AttributeMap;\n  private static handlers: { [embedType: string]: EmbedHandler\u003cunknown\u003e } = {};\n\n  static registerEmbed\u003cT\u003e(embedType: string, handler: EmbedHandler\u003cT\u003e): void {\n    this.handlers[embedType] = handler;\n  }\n\n  static unregisterEmbed(embedType: string): void {\n    delete this.handlers[embedType];\n  }\n\n  private static getHandler(embedType: string): EmbedHandler\u003cunknown\u003e {\n    const handler = this.handlers[embedType];\n    if (!handler) {\n      throw new Error(`no handlers for embed type \"${embedType}\"`);\n    }\n    return handler;\n  }\n\n  ops: Op[];\n  constructor(ops?: Op[] | { ops: Op[] }) {\n    // Assume we are given a well formed ops\n    if (Array.isArray(ops)) {\n      this.ops = ops;\n    } else if (ops != null \u0026\u0026 Array.isArray(ops.ops)) {\n      this.ops = ops.ops;\n    } else {\n      this.ops = [];\n    }\n  }\n\n  insert(\n    arg: string | Record\u003cstring, unknown\u003e,\n    attributes?: AttributeMap | null,\n  ): this {\n    const newOp: Op = {};\n    if (typeof arg === 'string' \u0026\u0026 arg.length === 0) {\n      return this;\n    }\n    newOp.insert = arg;\n    if (\n      attributes != null \u0026\u0026\n      typeof attributes === 'object' \u0026\u0026\n      Object.keys(attributes).length \u003e 0\n    ) {\n      newOp.attributes = attributes;\n    }\n    return this.push(newOp);\n  }\n\n  delete(length: number): this {\n    if (length \u003c= 0) {\n      return this;\n    }\n    return this.push({ delete: length });\n  }\n\n  retain(\n    length: number | Record\u003cstring, unknown\u003e,\n    attributes?: AttributeMap | null,\n  ): this {\n    if (typeof length === 'number' \u0026\u0026 length \u003c= 0) {\n      return this;\n    }\n    const newOp: Op = { retain: length };\n    if (\n      attributes != null \u0026\u0026\n      typeof attributes === 'object' \u0026\u0026\n      Object.keys(attributes).length \u003e 0\n    ) {\n      newOp.attributes = attributes;\n    }\n    return this.push(newOp);\n  }\n\n  push(newOp: Op): this {\n    let index = this.ops.length;\n    let lastOp = this.ops[index - 1];\n    newOp = cloneDeep(newOp);\n    if (typeof lastOp === 'object') {\n      if (\n        typeof newOp.delete === 'number' \u0026\u0026\n        typeof lastOp.delete === 'number'\n      ) {\n        this.ops[index - 1] = { delete: lastOp.delete + newOp.delete };\n        return this;\n      }\n      // Since it does not matter if we insert before or after deleting at the same index,\n      // always prefer to insert first\n      if (typeof lastOp.delete === 'number' \u0026\u0026 newOp.insert != null) {\n        index -= 1;\n        lastOp = this.ops[index - 1];\n        if (typeof lastOp !== 'object') {\n          this.ops.unshift(newOp);\n          return this;\n        }\n      }\n      if (isEqual(newOp.attributes, lastOp.attributes)) {\n        if (\n          typeof newOp.insert === 'string' \u0026\u0026\n          typeof lastOp.insert === 'string'\n        ) {\n          this.ops[index - 1] = { insert: lastOp.insert + newOp.insert };\n          if (typeof newOp.attributes === 'object') {\n            this.ops[index - 1].attributes = newOp.attributes;\n          }\n          return this;\n        } else if (\n          typeof newOp.retain === 'number' \u0026\u0026\n          typeof lastOp.retain === 'number'\n        ) {\n          this.ops[index - 1] = { retain: lastOp.retain + newOp.retain };\n          if (typeof newOp.attributes === 'object') {\n            this.ops[index - 1].attributes = newOp.attributes;\n          }\n          return this;\n        }\n      }\n    }\n    if (index === this.ops.length) {\n      this.ops.push(newOp);\n    } else {\n      this.ops.splice(index, 0, newOp);\n    }\n    return this;\n  }\n\n  chop(): this {\n    const lastOp = this.ops[this.ops.length - 1];\n    if (lastOp \u0026\u0026 typeof lastOp.retain === 'number' \u0026\u0026 !lastOp.attributes) {\n      this.ops.pop();\n    }\n    return this;\n  }\n\n  filter(predicate: (op: Op, index: number) =\u003e boolean): Op[] {\n    return this.ops.filter(predicate);\n  }\n\n  forEach(predicate: (op: Op, index: number) =\u003e void): void {\n    this.ops.forEach(predicate);\n  }\n\n  map\u003cT\u003e(predicate: (op: Op, index: number) =\u003e T): T[] {\n    return this.ops.map(predicate);\n  }\n\n  partition(predicate: (op: Op) =\u003e boolean): [Op[], Op[]] {\n    const passed: Op[] = [];\n    const failed: Op[] = [];\n    this.forEach((op) =\u003e {\n      const target = predicate(op) ? passed : failed;\n      target.push(op);\n    });\n    return [passed, failed];\n  }\n\n  reduce\u003cT\u003e(\n    predicate: (accum: T, curr: Op, index: number) =\u003e T,\n    initialValue: T,\n  ): T {\n    return this.ops.reduce(predicate, initialValue);\n  }\n\n  changeLength(): number {\n    return this.reduce((length, elem) =\u003e {\n      if (elem.insert) {\n        return length + Op.length(elem);\n      } else if (elem.delete) {\n        return length - elem.delete;\n      }\n      return length;\n    }, 0);\n  }\n\n  length(): number {\n    return this.reduce((length, elem) =\u003e {\n      return length + Op.length(elem);\n    }, 0);\n  }\n\n  slice(start = 0, end = Infinity): Delta {\n    const ops = [];\n    const iter = new OpIterator(this.ops);\n    let index = 0;\n    while (index \u003c end \u0026\u0026 iter.hasNext()) {\n      let nextOp;\n      if (index \u003c start) {\n        nextOp = iter.next(start - index);\n      } else {\n        nextOp = iter.next(end - index);\n        ops.push(nextOp);\n      }\n      index += Op.length(nextOp);\n    }\n    return new Delta(ops);\n  }\n\n  compose(other: Delta): Delta {\n    const thisIter = new OpIterator(this.ops);\n    const otherIter = new OpIterator(other.ops);\n    const ops = [];\n    const firstOther = otherIter.peek();\n    if (\n      firstOther != null \u0026\u0026\n      typeof firstOther.retain === 'number' \u0026\u0026\n      firstOther.attributes == null\n    ) {\n      let firstLeft = firstOther.retain;\n      while (\n        thisIter.peekType() === 'insert' \u0026\u0026\n        thisIter.peekLength() \u003c= firstLeft\n      ) {\n        firstLeft -= thisIter.peekLength();\n        ops.push(thisIter.next());\n      }\n      if (firstOther.retain - firstLeft \u003e 0) {\n        otherIter.next(firstOther.retain - firstLeft);\n      }\n    }\n    const delta = new Delta(ops);\n    while (thisIter.hasNext() || otherIter.hasNext()) {\n      if (otherIter.peekType() === 'insert') {\n        delta.push(otherIter.next());\n      } else if (thisIter.peekType() === 'delete') {\n        delta.push(thisIter.next());\n      } else {\n        const length = Math.min(thisIter.peekLength(), otherIter.peekLength());\n        const thisOp = thisIter.next(length);\n        const otherOp = otherIter.next(length);\n        if (otherOp.retain) {\n          const newOp: Op = {};\n          if (typeof thisOp.retain === 'number') {\n            newOp.retain =\n              typeof otherOp.retain === 'number' ? length : otherOp.retain;\n          } else {\n            if (typeof otherOp.retain === 'number') {\n              if (thisOp.retain == null) {\n                newOp.insert = thisOp.insert;\n              } else {\n                newOp.retain = thisOp.retain;\n              }\n            } else {\n              const action = thisOp.retain == null ? 'insert' : 'retain';\n              const [embedType, thisData, otherData] = getEmbedTypeAndData(\n                thisOp[action],\n                otherOp.retain,\n              );\n              const handler = Delta.getHandler(embedType);\n              newOp[action] = {\n                [embedType]: handler.compose(\n                  thisData,\n                  otherData,\n                  action === 'retain',\n                ),\n              };\n            }\n          }\n          // Preserve null when composing with a retain, otherwise remove it for inserts\n          const attributes = AttributeMap.compose(\n            thisOp.attributes,\n            otherOp.attributes,\n            typeof thisOp.retain === 'number',\n          );\n          if (attributes) {\n            newOp.attributes = attributes;\n          }\n          delta.push(newOp);\n\n          // Optimization if rest of other is just retain\n          if (\n            !otherIter.hasNext() \u0026\u0026\n            isEqual(delta.ops[delta.ops.length - 1], newOp)\n          ) {\n            const rest = new Delta(thisIter.rest());\n            return delta.concat(rest).chop();\n          }\n\n          // Other op should be delete, we could be an insert or retain\n          // Insert + delete cancels out\n        } else if (\n          typeof otherOp.delete === 'number' \u0026\u0026\n          (typeof thisOp.retain === 'number' ||\n            (typeof thisOp.retain === 'object' \u0026\u0026 thisOp.retain !== null))\n        ) {\n          delta.push(otherOp);\n        }\n      }\n    }\n    return delta.chop();\n  }\n\n  concat(other: Delta): Delta {\n    const delta = new Delta(this.ops.slice());\n    if (other.ops.length \u003e 0) {\n      delta.push(other.ops[0]);\n      delta.ops = delta.ops.concat(other.ops.slice(1));\n    }\n    return delta;\n  }\n\n  diff(other: Delta, cursor?: number | diff.CursorInfo): Delta {\n    if (this.ops === other.ops) {\n      return new Delta();\n    }\n    const strings = [this, other].map((delta) =\u003e {\n      return delta\n        .map((op) =\u003e {\n          if (op.insert != null) {\n            return typeof op.insert === 'string' ? op.insert : NULL_CHARACTER;\n          }\n          const prep = delta === other ? 'on' : 'with';\n          throw new Error('diff() called ' + prep + ' non-document');\n        })\n        .join('');\n    });\n    const retDelta = new Delta();\n    const diffResult = diff(strings[0], strings[1], cursor, true);\n    const thisIter = new OpIterator(this.ops);\n    const otherIter = new OpIterator(other.ops);\n    diffResult.forEach((component: diff.Diff) =\u003e {\n      let length = component[1].length;\n      while (length \u003e 0) {\n        let opLength = 0;\n        switch (component[0]) {\n          case diff.INSERT:\n            opLength = Math.min(otherIter.peekLength(), length);\n            retDelta.push(otherIter.next(opLength));\n            break;\n          case diff.DELETE:\n            opLength = Math.min(length, thisIter.peekLength());\n            thisIter.next(opLength);\n            retDelta.delete(opLength);\n            break;\n          case diff.EQUAL:\n            opLength = Math.min(\n              thisIter.peekLength(),\n              otherIter.peekLength(),\n              length,\n            );\n            const thisOp = thisIter.next(opLength);\n            const otherOp = otherIter.next(opLength);\n            if (isEqual(thisOp.insert, otherOp.insert)) {\n              retDelta.retain(\n                opLength,\n                AttributeMap.diff(thisOp.attributes, otherOp.attributes),\n              );\n            } else {\n              retDelta.push(otherOp).delete(opLength);\n            }\n            break;\n        }\n        length -= opLength;\n      }\n    });\n    return retDelta.chop();\n  }\n\n  eachLine(\n    predicate: (\n      line: Delta,\n      attributes: AttributeMap,\n      index: number,\n    ) =\u003e boolean | void,\n    newline = '\\n',\n  ): void {\n    const iter = new OpIterator(this.ops);\n    let line = new Delta();\n    let i = 0;\n    while (iter.hasNext()) {\n      if (iter.peekType() !== 'insert') {\n        return;\n      }\n      const thisOp = iter.peek();\n      const start = Op.length(thisOp) - iter.peekLength();\n      const index =\n        typeof thisOp.insert === 'string'\n          ? thisOp.insert.indexOf(newline, start) - start\n          : -1;\n      if (index \u003c 0) {\n        line.push(iter.next());\n      } else if (index \u003e 0) {\n        line.push(iter.next(index));\n      } else {\n        if (predicate(line, iter.next(1).attributes || {}, i) === false) {\n          return;\n        }\n        i += 1;\n        line = new Delta();\n      }\n    }\n    if (line.length() \u003e 0) {\n      predicate(line, {}, i);\n    }\n  }\n\n  invert(base: Delta): Delta {\n    const inverted = new Delta();\n    this.reduce((baseIndex, op) =\u003e {\n      if (op.insert) {\n        inverted.delete(Op.length(op));\n      } else if (typeof op.retain === 'number' \u0026\u0026 op.attributes == null) {\n        inverted.retain(op.retain);\n        return baseIndex + op.retain;\n      } else if (op.delete || typeof op.retain === 'number') {\n        const length = (op.delete || op.retain) as number;\n        const slice = base.slice(baseIndex, baseIndex + length);\n        slice.forEach((baseOp) =\u003e {\n          if (op.delete) {\n            inverted.push(baseOp);\n          } else if (op.retain \u0026\u0026 op.attributes) {\n            inverted.retain(\n              Op.length(baseOp),\n              AttributeMap.invert(op.attributes, baseOp.attributes),\n            );\n          }\n        });\n        return baseIndex + length;\n      } else if (typeof op.retain === 'object' \u0026\u0026 op.retain !== null) {\n        const slice = base.slice(baseIndex, baseIndex + 1);\n        const baseOp = new OpIterator(slice.ops).next();\n        const [embedType, opData, baseOpData] = getEmbedTypeAndData(\n          op.retain,\n          baseOp.insert,\n        );\n        const handler = Delta.getHandler(embedType);\n        inverted.retain(\n          { [embedType]: handler.invert(opData, baseOpData) },\n          AttributeMap.invert(op.attributes, baseOp.attributes),\n        );\n        return baseIndex + 1;\n      }\n      return baseIndex;\n    }, 0);\n    return inverted.chop();\n  }\n\n  transform(index: number, priority?: boolean): number;\n  transform(other: Delta, priority?: boolean): Delta;\n  transform(arg: number | Delta, priority = false): typeof arg {\n    priority = !!priority;\n    if (typeof arg === 'number') {\n      return this.transformPosition(arg, priority);\n    }\n    const other: Delta = arg;\n    const thisIter = new OpIterator(this.ops);\n    const otherIter = new OpIterator(other.ops);\n    const delta = new Delta();\n    while (thisIter.hasNext() || otherIter.hasNext()) {\n      if (\n        thisIter.peekType() === 'insert' \u0026\u0026\n        (priority || otherIter.peekType() !== 'insert')\n      ) {\n        delta.retain(Op.length(thisIter.next()));\n      } else if (otherIter.peekType() === 'insert') {\n        delta.push(otherIter.next());\n      } else {\n        const length = Math.min(thisIter.peekLength(), otherIter.peekLength());\n        const thisOp = thisIter.next(length);\n        const otherOp = otherIter.next(length);\n        if (thisOp.delete) {\n          // Our delete either makes their delete redundant or removes their retain\n          continue;\n        } else if (otherOp.delete) {\n          delta.push(otherOp);\n        } else {\n          const thisData = thisOp.retain;\n          const otherData = otherOp.retain;\n          let transformedData: Op['retain'] =\n            typeof otherData === 'object' \u0026\u0026 otherData !== null\n              ? otherData\n              : length;\n          if (\n            typeof thisData === 'object' \u0026\u0026\n            thisData !== null \u0026\u0026\n            typeof otherData === 'object' \u0026\u0026\n            otherData !== null\n          ) {\n            const embedType = Object.keys(thisData)[0];\n            if (embedType === Object.keys(otherData)[0]) {\n              const handler = Delta.getHandler(embedType);\n              if (handler) {\n                transformedData = {\n                  [embedType]: handler.transform(\n                    thisData[embedType],\n                    otherData[embedType],\n                    priority,\n                  ),\n                };\n              }\n            }\n          }\n\n          // We retain either their retain or insert\n          delta.retain(\n            transformedData,\n            AttributeMap.transform(\n              thisOp.attributes,\n              otherOp.attributes,\n              priority,\n            ),\n          );\n        }\n      }\n    }\n    return delta.chop();\n  }\n\n  transformPosition(index: number, priority = false): number {\n    priority = !!priority;\n    const thisIter = new OpIterator(this.ops);\n    let offset = 0;\n    while (thisIter.hasNext() \u0026\u0026 offset \u003c= index) {\n      const length = thisIter.peekLength();\n      const nextType = thisIter.peekType();\n      thisIter.next();\n      if (nextType === 'delete') {\n        index -= Math.min(length, index - offset);\n        continue;\n      } else if (nextType === 'insert' \u0026\u0026 (offset \u003c index || !priority)) {\n        index += length;\n      }\n      offset += length;\n    }\n    return index;\n  }\n}\n\nexport default Delta;\n\nexport { Op, OpIterator, AttributeMap };\n\nif (typeof module === 'object') {\n  module.exports = Delta;\n  module.exports.default = Delta;\n}\n","import * as cjsm from \"quill-delta\";export { __esModule,AttributeMap,OpIterator,Op } from \"quill-delta\";export default cjsm.default ?? cjsm;"],"version":3}