{"version":3,"file":"index.cjs","names":["DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","diff","makeDiff","C"],"sources":["../node_modules/.pnpm/@sanity+diff-match-patch@3.2.0/node_modules/@sanity/diff-match-patch/dist/index.js","../src/helpers/throttle.ts","../src/helpers/debounce.ts","../src/helpers/normalizeContent.ts","../src/visuals/getCurve.ts","../src/constants.ts","../src/visuals/getMode.ts","../src/visuals/getTheme.ts","../src/visuals/getLine.ts","../src/visuals/getEditorHeight.ts","../src/visuals/createArrow.ts","../src/dom/ensureElement.ts","../src/dom/query.ts","../src/AceDiff.ts"],"sourcesContent":["function cloneDiff(diff2) {\n  const [type, patch] = diff2;\n  return [type, patch];\n}\nfunction getCommonOverlap(textA, textB) {\n  let text1 = textA, text2 = textB;\n  const text1Length = text1.length, text2Length = text2.length;\n  if (text1Length === 0 || text2Length === 0)\n    return 0;\n  text1Length > text2Length ? text1 = text1.substring(text1Length - text2Length) : text1Length < text2Length && (text2 = text2.substring(0, text1Length));\n  const textLength = Math.min(text1Length, text2Length);\n  if (text1 === text2)\n    return textLength;\n  let best = 0, length = 1;\n  for (let found = 0; found !== -1; ) {\n    const pattern = text1.substring(textLength - length);\n    if (found = text2.indexOf(pattern), found === -1)\n      return best;\n    length += found, (found === 0 || text1.substring(textLength - length) === text2.substring(0, length)) && (best = length, length++);\n  }\n  return best;\n}\nfunction getCommonPrefix(text1, text2) {\n  if (!text1 || !text2 || text1[0] !== text2[0])\n    return 0;\n  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerStart = 0;\n  for (; pointerMin < pointerMid; )\n    text1.substring(pointerStart, pointerMid) === text2.substring(pointerStart, pointerMid) ? (pointerMin = pointerMid, pointerStart = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);\n  return pointerMid;\n}\nfunction getCommonSuffix(text1, text2) {\n  if (!text1 || !text2 || text1[text1.length - 1] !== text2[text2.length - 1])\n    return 0;\n  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerEnd = 0;\n  for (; pointerMin < pointerMid; )\n    text1.substring(text1.length - pointerMid, text1.length - pointerEnd) === text2.substring(text2.length - pointerMid, text2.length - pointerEnd) ? (pointerMin = pointerMid, pointerEnd = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);\n  return pointerMid;\n}\nfunction isHighSurrogate(char) {\n  const charCode = char.charCodeAt(0);\n  return charCode >= 55296 && charCode <= 56319;\n}\nfunction isLowSurrogate(char) {\n  const charCode = char.charCodeAt(0);\n  return charCode >= 56320 && charCode <= 57343;\n}\nfunction bisect(text1, text2, deadline) {\n  const text1Length = text1.length, text2Length = text2.length, maxD = Math.ceil((text1Length + text2Length) / 2), vOffset = maxD, vLength = 2 * maxD, v1 = new Array(vLength), v2 = new Array(vLength);\n  for (let x = 0; x < vLength; x++)\n    v1[x] = -1, v2[x] = -1;\n  v1[vOffset + 1] = 0, v2[vOffset + 1] = 0;\n  const delta = text1Length - text2Length, front = delta % 2 !== 0;\n  let k1start = 0, k1end = 0, k2start = 0, k2end = 0;\n  for (let d = 0; d < maxD && !(Date.now() > deadline); d++) {\n    for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\n      const k1Offset = vOffset + k1;\n      let x1;\n      k1 === -d || k1 !== d && v1[k1Offset - 1] < v1[k1Offset + 1] ? x1 = v1[k1Offset + 1] : x1 = v1[k1Offset - 1] + 1;\n      let y1 = x1 - k1;\n      for (; x1 < text1Length && y1 < text2Length && text1.charAt(x1) === text2.charAt(y1); )\n        x1++, y1++;\n      if (v1[k1Offset] = x1, x1 > text1Length)\n        k1end += 2;\n      else if (y1 > text2Length)\n        k1start += 2;\n      else if (front) {\n        const k2Offset = vOffset + delta - k1;\n        if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {\n          const x2 = text1Length - v2[k2Offset];\n          if (x1 >= x2)\n            return bisectSplit(text1, text2, x1, y1, deadline);\n        }\n      }\n    }\n    for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\n      const k2Offset = vOffset + k2;\n      let x2;\n      k2 === -d || k2 !== d && v2[k2Offset - 1] < v2[k2Offset + 1] ? x2 = v2[k2Offset + 1] : x2 = v2[k2Offset - 1] + 1;\n      let y2 = x2 - k2;\n      for (; x2 < text1Length && y2 < text2Length && text1.charAt(text1Length - x2 - 1) === text2.charAt(text2Length - y2 - 1); )\n        x2++, y2++;\n      if (v2[k2Offset] = x2, x2 > text1Length)\n        k2end += 2;\n      else if (y2 > text2Length)\n        k2start += 2;\n      else if (!front) {\n        const k1Offset = vOffset + delta - k2;\n        if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {\n          const x1 = v1[k1Offset], y1 = vOffset + x1 - k1Offset;\n          if (x2 = text1Length - x2, x1 >= x2)\n            return bisectSplit(text1, text2, x1, y1, deadline);\n        }\n      }\n    }\n  }\n  return [\n    [DIFF_DELETE, text1],\n    [DIFF_INSERT, text2]\n  ];\n}\nfunction bisectSplit(text1, text2, x, y, deadline) {\n  const text1a = text1.substring(0, x), text2a = text2.substring(0, y), text1b = text1.substring(x), text2b = text2.substring(y), diffs = doDiff(text1a, text2a, { checkLines: !1, deadline }), diffsb = doDiff(text1b, text2b, { checkLines: !1, deadline });\n  return diffs.concat(diffsb);\n}\nfunction findHalfMatch(text1, text2, timeout = 1) {\n  if (timeout <= 0)\n    return null;\n  const longText = text1.length > text2.length ? text1 : text2, shortText = text1.length > text2.length ? text2 : text1;\n  if (longText.length < 4 || shortText.length * 2 < longText.length)\n    return null;\n  const halfMatch1 = halfMatchI(longText, shortText, Math.ceil(longText.length / 4)), halfMatch2 = halfMatchI(longText, shortText, Math.ceil(longText.length / 2));\n  let halfMatch;\n  if (halfMatch1 && halfMatch2)\n    halfMatch = halfMatch1[4].length > halfMatch2[4].length ? halfMatch1 : halfMatch2;\n  else {\n    if (!halfMatch1 && !halfMatch2)\n      return null;\n    halfMatch2 ? halfMatch1 || (halfMatch = halfMatch2) : halfMatch = halfMatch1;\n  }\n  if (!halfMatch)\n    throw new Error(\"Unable to find a half match.\");\n  let text1A, text1B, text2A, text2B;\n  text1.length > text2.length ? (text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3]) : (text2A = halfMatch[0], text2B = halfMatch[1], text1A = halfMatch[2], text1B = halfMatch[3]);\n  const midCommon = halfMatch[4];\n  return [text1A, text1B, text2A, text2B, midCommon];\n}\nfunction halfMatchI(longText, shortText, i) {\n  const seed = longText.slice(i, i + Math.floor(longText.length / 4));\n  let j = -1, bestCommon = \"\", bestLongTextA, bestLongTextB, bestShortTextA, bestShortTextB;\n  for (; (j = shortText.indexOf(seed, j + 1)) !== -1; ) {\n    const prefixLength = getCommonPrefix(longText.slice(i), shortText.slice(j)), suffixLength = getCommonSuffix(longText.slice(0, i), shortText.slice(0, j));\n    bestCommon.length < suffixLength + prefixLength && (bestCommon = shortText.slice(j - suffixLength, j) + shortText.slice(j, j + prefixLength), bestLongTextA = longText.slice(0, i - suffixLength), bestLongTextB = longText.slice(i + prefixLength), bestShortTextA = shortText.slice(0, j - suffixLength), bestShortTextB = shortText.slice(j + prefixLength));\n  }\n  return bestCommon.length * 2 >= longText.length ? [\n    bestLongTextA || \"\",\n    bestLongTextB || \"\",\n    bestShortTextA || \"\",\n    bestShortTextB || \"\",\n    bestCommon || \"\"\n  ] : null;\n}\nfunction charsToLines(diffs, lineArray) {\n  for (let x = 0; x < diffs.length; x++) {\n    const chars = diffs[x][1], text = [];\n    for (let y = 0; y < chars.length; y++)\n      text[y] = lineArray[chars.charCodeAt(y)];\n    diffs[x][1] = text.join(\"\");\n  }\n}\nfunction linesToChars(textA, textB) {\n  const lineArray = [], lineHash = {};\n  lineArray[0] = \"\";\n  function diffLinesToMunge(text) {\n    let chars = \"\", lineStart = 0, lineEnd = -1, lineArrayLength = lineArray.length;\n    for (; lineEnd < text.length - 1; ) {\n      lineEnd = text.indexOf(`\n`, lineStart), lineEnd === -1 && (lineEnd = text.length - 1);\n      let line = text.slice(lineStart, lineEnd + 1);\n      (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : lineHash[line] !== void 0) ? chars += String.fromCharCode(lineHash[line]) : (lineArrayLength === maxLines && (line = text.slice(lineStart), lineEnd = text.length), chars += String.fromCharCode(lineArrayLength), lineHash[line] = lineArrayLength, lineArray[lineArrayLength++] = line), lineStart = lineEnd + 1;\n    }\n    return chars;\n  }\n  let maxLines = 4e4;\n  const chars1 = diffLinesToMunge(textA);\n  maxLines = 65535;\n  const chars2 = diffLinesToMunge(textB);\n  return { chars1, chars2, lineArray };\n}\nfunction doLineModeDiff(textA, textB, opts) {\n  let text1 = textA, text2 = textB;\n  const a = linesToChars(text1, text2);\n  text1 = a.chars1, text2 = a.chars2;\n  const linearray = a.lineArray;\n  let diffs = doDiff(text1, text2, {\n    checkLines: !1,\n    deadline: opts.deadline\n  });\n  charsToLines(diffs, linearray), diffs = cleanupSemantic(diffs), diffs.push([DIFF_EQUAL, \"\"]);\n  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = \"\", textInsert = \"\";\n  for (; pointer < diffs.length; ) {\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n        countInsert++, textInsert += diffs[pointer][1];\n        break;\n      case DIFF_DELETE:\n        countDelete++, textDelete += diffs[pointer][1];\n        break;\n      case DIFF_EQUAL:\n        if (countDelete >= 1 && countInsert >= 1) {\n          diffs.splice(pointer - countDelete - countInsert, countDelete + countInsert), pointer = pointer - countDelete - countInsert;\n          const aa = doDiff(textDelete, textInsert, {\n            checkLines: !1,\n            deadline: opts.deadline\n          });\n          for (let j = aa.length - 1; j >= 0; j--)\n            diffs.splice(pointer, 0, aa[j]);\n          pointer += aa.length;\n        }\n        countInsert = 0, countDelete = 0, textDelete = \"\", textInsert = \"\";\n        break;\n      default:\n        throw new Error(\"Unknown diff operation.\");\n    }\n    pointer++;\n  }\n  return diffs.pop(), diffs;\n}\nfunction computeDiff(text1, text2, opts) {\n  let diffs;\n  if (!text1)\n    return [[DIFF_INSERT, text2]];\n  if (!text2)\n    return [[DIFF_DELETE, text1]];\n  const longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1, i = longtext.indexOf(shorttext);\n  if (i !== -1)\n    return diffs = [\n      [DIFF_INSERT, longtext.substring(0, i)],\n      [DIFF_EQUAL, shorttext],\n      [DIFF_INSERT, longtext.substring(i + shorttext.length)]\n    ], text1.length > text2.length && (diffs[0][0] = DIFF_DELETE, diffs[2][0] = DIFF_DELETE), diffs;\n  if (shorttext.length === 1)\n    return [\n      [DIFF_DELETE, text1],\n      [DIFF_INSERT, text2]\n    ];\n  const halfMatch = findHalfMatch(text1, text2);\n  if (halfMatch) {\n    const text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3], midCommon = halfMatch[4], diffsA = doDiff(text1A, text2A, opts), diffsB = doDiff(text1B, text2B, opts);\n    return diffsA.concat([[DIFF_EQUAL, midCommon]], diffsB);\n  }\n  return opts.checkLines && text1.length > 100 && text2.length > 100 ? doLineModeDiff(text1, text2, opts) : bisect(text1, text2, opts.deadline);\n}\nvar __defProp$2 = Object.defineProperty, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$2 = (a, b) => {\n  for (var prop in b || (b = {}))\n    __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);\n  if (__getOwnPropSymbols$2)\n    for (var prop of __getOwnPropSymbols$2(b))\n      __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);\n  return a;\n};\nconst DIFF_DELETE = -1, DIFF_INSERT = 1, DIFF_EQUAL = 0;\nfunction diff(textA, textB, opts) {\n  if (textA === null || textB === null)\n    throw new Error(\"Null input. (diff)\");\n  const diffs = doDiff(textA, textB, createInternalOpts(opts || {}));\n  return adjustDiffForSurrogatePairs(diffs), diffs;\n}\nfunction doDiff(textA, textB, options) {\n  let text1 = textA, text2 = textB;\n  if (text1 === text2)\n    return text1 ? [[DIFF_EQUAL, text1]] : [];\n  let commonlength = getCommonPrefix(text1, text2);\n  const commonprefix = text1.substring(0, commonlength);\n  text1 = text1.substring(commonlength), text2 = text2.substring(commonlength), commonlength = getCommonSuffix(text1, text2);\n  const commonsuffix = text1.substring(text1.length - commonlength);\n  text1 = text1.substring(0, text1.length - commonlength), text2 = text2.substring(0, text2.length - commonlength);\n  let diffs = computeDiff(text1, text2, options);\n  return commonprefix && diffs.unshift([DIFF_EQUAL, commonprefix]), commonsuffix && diffs.push([DIFF_EQUAL, commonsuffix]), diffs = cleanupMerge(diffs), diffs;\n}\nfunction createDeadLine(timeout) {\n  let t = 1;\n  return typeof timeout < \"u\" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;\n}\nfunction createInternalOpts(opts) {\n  return __spreadValues$2({\n    checkLines: !0,\n    deadline: createDeadLine(opts.timeout || 1)\n  }, opts);\n}\nfunction combineChar(data, char, dir) {\n  return dir === 1 ? data + char : char + data;\n}\nfunction splitChar(data, dir) {\n  return dir === 1 ? [data.substring(0, data.length - 1), data[data.length - 1]] : [data.substring(1), data[0]];\n}\nfunction hasSharedChar(diffs, i, j, dir) {\n  return dir === 1 ? diffs[i][1][diffs[i][1].length - 1] === diffs[j][1][diffs[j][1].length - 1] : diffs[i][1][0] === diffs[j][1][0];\n}\nfunction deisolateChar(diffs, i, dir) {\n  const inv = dir === 1 ? -1 : 1;\n  let insertIdx = null, deleteIdx = null, j = i + dir;\n  for (; j >= 0 && j < diffs.length && (insertIdx === null || deleteIdx === null); j += dir) {\n    const [op, text2] = diffs[j];\n    if (text2.length !== 0) {\n      if (op === DIFF_INSERT) {\n        insertIdx === null && (insertIdx = j);\n        continue;\n      } else if (op === DIFF_DELETE) {\n        deleteIdx === null && (deleteIdx = j);\n        continue;\n      } else if (op === DIFF_EQUAL) {\n        if (insertIdx === null && deleteIdx === null) {\n          const [rest, char2] = splitChar(diffs[i][1], dir);\n          diffs[i][1] = rest, diffs[j][1] = combineChar(diffs[j][1], char2, inv);\n          return;\n        }\n        break;\n      }\n    }\n  }\n  if (insertIdx !== null && deleteIdx !== null && hasSharedChar(diffs, insertIdx, deleteIdx, dir)) {\n    const [insertText, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText] = splitChar(diffs[deleteIdx][1], inv);\n    diffs[insertIdx][1] = insertText, diffs[deleteIdx][1] = deleteText, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);\n    return;\n  }\n  const [text, char] = splitChar(diffs[i][1], dir);\n  diffs[i][1] = text, insertIdx === null ? (diffs.splice(j, 0, [DIFF_INSERT, char]), deleteIdx !== null && deleteIdx >= j && deleteIdx++) : diffs[insertIdx][1] = combineChar(diffs[insertIdx][1], char, inv), deleteIdx === null ? diffs.splice(j, 0, [DIFF_DELETE, char]) : diffs[deleteIdx][1] = combineChar(diffs[deleteIdx][1], char, inv);\n}\nfunction adjustDiffForSurrogatePairs(diffs) {\n  for (let i = 0; i < diffs.length; i++) {\n    const [diffType, diffText] = diffs[i];\n    if (diffText.length === 0) continue;\n    const firstChar = diffText[0], lastChar = diffText[diffText.length - 1];\n    isHighSurrogate(lastChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, 1), isLowSurrogate(firstChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, -1);\n  }\n  for (let i = 0; i < diffs.length; i++)\n    diffs[i][1].length === 0 && diffs.splice(i, 1);\n}\nfunction cleanupSemantic(rawDiffs) {\n  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;\n  const equalities = [];\n  let equalitiesLength = 0, lastEquality = null, pointer = 0, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0;\n  for (; pointer < diffs.length; )\n    diffs[pointer][0] === DIFF_EQUAL ? (equalities[equalitiesLength++] = pointer, lengthInsertions1 = lengthInsertions2, lengthDeletions1 = lengthDeletions2, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = diffs[pointer][1]) : (diffs[pointer][0] === DIFF_INSERT ? lengthInsertions2 += diffs[pointer][1].length : lengthDeletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(lengthInsertions1, lengthDeletions1) && lastEquality.length <= Math.max(lengthInsertions2, lengthDeletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = null, hasChanges = !0)), pointer++;\n  for (hasChanges && (diffs = cleanupMerge(diffs)), diffs = cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length; ) {\n    if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {\n      const deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlapLength1 = getCommonOverlap(deletion, insertion), overlapLength2 = getCommonOverlap(insertion, deletion);\n      overlapLength1 >= overlapLength2 ? (overlapLength1 >= deletion.length / 2 || overlapLength1 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, insertion.substring(0, overlapLength1)]), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlapLength1), diffs[pointer + 1][1] = insertion.substring(overlapLength1), pointer++) : (overlapLength2 >= deletion.length / 2 || overlapLength2 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, deletion.substring(0, overlapLength2)]), diffs[pointer - 1][0] = DIFF_INSERT, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlapLength2), diffs[pointer + 1][0] = DIFF_DELETE, diffs[pointer + 1][1] = deletion.substring(overlapLength2), pointer++), pointer++;\n    }\n    pointer++;\n  }\n  return diffs;\n}\nconst nonAlphaNumericRegex = /[^a-zA-Z0-9]/, whitespaceRegex = /\\s/, linebreakRegex = /[\\r\\n]/, blanklineEndRegex = /\\n\\r?\\n$/, blanklineStartRegex = /^\\r?\\n\\r?\\n/;\nfunction cleanupSemanticLossless(rawDiffs) {\n  const diffs = rawDiffs.map((diff2) => cloneDiff(diff2));\n  function diffCleanupSemanticScore(one, two) {\n    if (!one || !two)\n      return 6;\n    const char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex), nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex), whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex), whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex), lineBreak1 = whitespace1 && char1.match(linebreakRegex), lineBreak2 = whitespace2 && char2.match(linebreakRegex), blankLine1 = lineBreak1 && one.match(blanklineEndRegex), blankLine2 = lineBreak2 && two.match(blanklineStartRegex);\n    return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;\n  }\n  let pointer = 1;\n  for (; pointer < diffs.length - 1; ) {\n    if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {\n      let equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1];\n      const commonOffset = getCommonSuffix(equality1, edit);\n      if (commonOffset) {\n        const commonString = edit.substring(edit.length - commonOffset);\n        equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;\n      }\n      let bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);\n      for (; edit.charAt(0) === equality2.charAt(0); ) {\n        equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);\n        const score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);\n        score >= bestScore && (bestScore = score, bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2);\n      }\n      diffs[pointer - 1][1] !== bestEquality1 && (bestEquality1 ? diffs[pointer - 1][1] = bestEquality1 : (diffs.splice(pointer - 1, 1), pointer--), diffs[pointer][1] = bestEdit, bestEquality2 ? diffs[pointer + 1][1] = bestEquality2 : (diffs.splice(pointer + 1, 1), pointer--));\n    }\n    pointer++;\n  }\n  return diffs;\n}\nfunction cleanupMerge(rawDiffs) {\n  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));\n  diffs.push([DIFF_EQUAL, \"\"]);\n  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = \"\", textInsert = \"\", commonlength;\n  for (; pointer < diffs.length; )\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n        countInsert++, textInsert += diffs[pointer][1], pointer++;\n        break;\n      case DIFF_DELETE:\n        countDelete++, textDelete += diffs[pointer][1], pointer++;\n        break;\n      case DIFF_EQUAL:\n        countDelete + countInsert > 1 ? (countDelete !== 0 && countInsert !== 0 && (commonlength = getCommonPrefix(textInsert, textDelete), commonlength !== 0 && (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === DIFF_EQUAL ? diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(\n          0,\n          commonlength\n        ) : (diffs.splice(0, 0, [DIFF_EQUAL, textInsert.substring(0, commonlength)]), pointer++), textInsert = textInsert.substring(commonlength), textDelete = textDelete.substring(commonlength)), commonlength = getCommonSuffix(textInsert, textDelete), commonlength !== 0 && (diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1], textInsert = textInsert.substring(0, textInsert.length - commonlength), textDelete = textDelete.substring(0, textDelete.length - commonlength))), pointer -= countDelete + countInsert, diffs.splice(pointer, countDelete + countInsert), textDelete.length && (diffs.splice(pointer, 0, [DIFF_DELETE, textDelete]), pointer++), textInsert.length && (diffs.splice(pointer, 0, [DIFF_INSERT, textInsert]), pointer++), pointer++) : pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, countInsert = 0, countDelete = 0, textDelete = \"\", textInsert = \"\";\n        break;\n      default:\n        throw new Error(\"Unknown diff operation\");\n    }\n  diffs[diffs.length - 1][1] === \"\" && diffs.pop();\n  let hasChanges = !1;\n  for (pointer = 1; pointer < diffs.length - 1; )\n    diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL && (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1] ? (diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length), diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1], diffs.splice(pointer - 1, 1), hasChanges = !0) : diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1] && (diffs[pointer - 1][1] += diffs[pointer + 1][1], diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1], diffs.splice(pointer + 1, 1), hasChanges = !0)), pointer++;\n  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;\n}\nfunction trueCount(...args) {\n  return args.reduce((n, bool) => n + (bool ? 1 : 0), 0);\n}\nfunction cleanupEfficiency(rawDiffs, editCost = 4) {\n  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;\n  const equalities = [];\n  let equalitiesLength = 0, lastEquality = null, pointer = 0, preIns = !1, preDel = !1, postIns = !1, postDel = !1;\n  for (; pointer < diffs.length; )\n    diffs[pointer][0] === DIFF_EQUAL ? (diffs[pointer][1].length < editCost && (postIns || postDel) ? (equalities[equalitiesLength++] = pointer, preIns = postIns, preDel = postDel, lastEquality = diffs[pointer][1]) : (equalitiesLength = 0, lastEquality = null), postIns = !1, postDel = !1) : (diffs[pointer][0] === DIFF_DELETE ? postDel = !0 : postIns = !0, lastEquality && (preIns && preDel && postIns && postDel || lastEquality.length < editCost / 2 && trueCount(preIns, preDel, postIns, postDel) === 3) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, lastEquality = null, preIns && preDel ? (postIns = !0, postDel = !0, equalitiesLength = 0) : (equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, postIns = !1, postDel = !1), hasChanges = !0)), pointer++;\n  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;\n}\nvar __defProp$1 = Object.defineProperty, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$1 = (a, b) => {\n  for (var prop in b || (b = {}))\n    __hasOwnProp$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);\n  if (__getOwnPropSymbols$1)\n    for (var prop of __getOwnPropSymbols$1(b))\n      __propIsEnum$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);\n  return a;\n};\nconst DEFAULT_OPTIONS = {\n  /**\n   * At what point is no match declared (0.0 = perfection, 1.0 = very loose).\n   */\n  threshold: 0.5,\n  /**\n   * How far to search for a match (0 = exact location, 1000+ = broad match).\n   * A match this many characters away from the expected location will add\n   * 1.0 to the score (0.0 is a perfect match).\n   */\n  distance: 1e3\n};\nfunction applyDefaults(options) {\n  return __spreadValues$1(__spreadValues$1({}, DEFAULT_OPTIONS), options);\n}\nconst MAX_BITS$1 = 32;\nfunction bitap(text, pattern, loc, opts = {}) {\n  if (pattern.length > MAX_BITS$1)\n    throw new Error(\"Pattern too long for this browser.\");\n  const options = applyDefaults(opts), s = getAlphabetFromPattern(pattern);\n  function getBitapScore(e, x) {\n    const accuracy = e / pattern.length, proximity = Math.abs(loc - x);\n    return options.distance ? accuracy + proximity / options.distance : proximity ? 1 : accuracy;\n  }\n  let scoreThreshold = options.threshold, bestLoc = text.indexOf(pattern, loc);\n  bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold), bestLoc = text.lastIndexOf(pattern, loc + pattern.length), bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold)));\n  const matchmask = 1 << pattern.length - 1;\n  bestLoc = -1;\n  let binMin, binMid, binMax = pattern.length + text.length, lastRd = [];\n  for (let d = 0; d < pattern.length; d++) {\n    for (binMin = 0, binMid = binMax; binMin < binMid; )\n      getBitapScore(d, loc + binMid) <= scoreThreshold ? binMin = binMid : binMax = binMid, binMid = Math.floor((binMax - binMin) / 2 + binMin);\n    binMax = binMid;\n    let start = Math.max(1, loc - binMid + 1);\n    const finish = Math.min(loc + binMid, text.length) + pattern.length, rd = new Array(finish + 2);\n    rd[finish + 1] = (1 << d) - 1;\n    for (let j = finish; j >= start; j--) {\n      const charMatch = s[text.charAt(j - 1)];\n      if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | ((lastRd[j + 1] | lastRd[j]) << 1 | 1) | lastRd[j + 1], rd[j] & matchmask) {\n        const score = getBitapScore(d, j - 1);\n        if (score <= scoreThreshold)\n          if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc)\n            start = Math.max(1, 2 * loc - bestLoc);\n          else\n            break;\n      }\n    }\n    if (getBitapScore(d + 1, loc) > scoreThreshold)\n      break;\n    lastRd = rd;\n  }\n  return bestLoc;\n}\nfunction getAlphabetFromPattern(pattern) {\n  const s = {};\n  for (let i = 0; i < pattern.length; i++)\n    s[pattern.charAt(i)] = 0;\n  for (let i = 0; i < pattern.length; i++)\n    s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;\n  return s;\n}\nfunction match(text, pattern, searchLocation, options = {}) {\n  if (text === null || pattern === null || searchLocation === null)\n    throw new Error(\"Null input. (match())\");\n  const loc = Math.max(0, Math.min(searchLocation, text.length));\n  if (text === pattern)\n    return 0;\n  if (text.length) {\n    if (text.substring(loc, loc + pattern.length) === pattern)\n      return loc;\n  } else return -1;\n  return bitap(text, pattern, loc, options);\n}\nfunction diffText1(diffs) {\n  const text = [];\n  for (let x = 0; x < diffs.length; x++)\n    diffs[x][0] !== DIFF_INSERT && (text[x] = diffs[x][1]);\n  return text.join(\"\");\n}\nfunction diffText2(diffs) {\n  const text = [];\n  for (let x = 0; x < diffs.length; x++)\n    diffs[x][0] !== DIFF_DELETE && (text[x] = diffs[x][1]);\n  return text.join(\"\");\n}\nfunction levenshtein(diffs) {\n  let leven = 0, insertions = 0, deletions = 0;\n  for (let x = 0; x < diffs.length; x++) {\n    const op = diffs[x][0], data = diffs[x][1];\n    switch (op) {\n      case DIFF_INSERT:\n        insertions += data.length;\n        break;\n      case DIFF_DELETE:\n        deletions += data.length;\n        break;\n      case DIFF_EQUAL:\n        leven += Math.max(insertions, deletions), insertions = 0, deletions = 0;\n        break;\n      default:\n        throw new Error(\"Unknown diff operation.\");\n    }\n  }\n  return leven += Math.max(insertions, deletions), leven;\n}\nfunction xIndex(diffs, location) {\n  let chars1 = 0, chars2 = 0, lastChars1 = 0, lastChars2 = 0, x;\n  for (x = 0; x < diffs.length && (diffs[x][0] !== DIFF_INSERT && (chars1 += diffs[x][1].length), diffs[x][0] !== DIFF_DELETE && (chars2 += diffs[x][1].length), !(chars1 > location)); x++)\n    lastChars1 = chars1, lastChars2 = chars2;\n  return diffs.length !== x && diffs[x][0] === DIFF_DELETE ? lastChars2 : lastChars2 + (location - lastChars1);\n}\nfunction countUtf8Bytes(str) {\n  let bytes = 0;\n  for (let i = 0; i < str.length; i++) {\n    const codePoint = str.codePointAt(i);\n    if (typeof codePoint > \"u\")\n      throw new Error(\"Failed to get codepoint\");\n    bytes += utf8len(codePoint);\n  }\n  return bytes;\n}\nfunction adjustIndiciesToUcs2(patches, base, options = {}) {\n  let byteOffset = 0, idx = 0;\n  function advanceTo(target) {\n    for (; byteOffset < target; ) {\n      const codePoint = base.codePointAt(idx);\n      if (typeof codePoint > \"u\")\n        return idx;\n      byteOffset += utf8len(codePoint), codePoint > 65535 ? idx += 2 : idx += 1;\n    }\n    if (!options.allowExceedingIndices && byteOffset !== target)\n      throw new Error(\"Failed to determine byte offset\");\n    return idx;\n  }\n  const adjusted = [];\n  for (const patch of patches)\n    adjusted.push({\n      diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),\n      start1: advanceTo(patch.start1),\n      start2: advanceTo(patch.start2),\n      utf8Start1: patch.utf8Start1,\n      utf8Start2: patch.utf8Start2,\n      length1: patch.length1,\n      length2: patch.length2,\n      utf8Length1: patch.utf8Length1,\n      utf8Length2: patch.utf8Length2\n    });\n  return adjusted;\n}\nfunction utf8len(codePoint) {\n  return codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;\n}\nconst MAX_BITS = 32, DEFAULT_MARGIN = 4;\nfunction addPadding(patches, margin = DEFAULT_MARGIN) {\n  const paddingLength = margin;\n  let nullPadding = \"\";\n  for (let x = 1; x <= paddingLength; x++)\n    nullPadding += String.fromCharCode(x);\n  for (const p of patches)\n    p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;\n  let patch = patches[0], diffs = patch.diffs;\n  if (diffs.length === 0 || diffs[0][0] !== DIFF_EQUAL)\n    diffs.unshift([DIFF_EQUAL, nullPadding]), patch.start1 -= paddingLength, patch.start2 -= paddingLength, patch.utf8Start1 -= paddingLength, patch.utf8Start2 -= paddingLength, patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;\n  else if (paddingLength > diffs[0][1].length) {\n    const firstDiffLength = diffs[0][1].length, extraLength = paddingLength - firstDiffLength;\n    diffs[0][1] = nullPadding.substring(firstDiffLength) + diffs[0][1], patch.start1 -= extraLength, patch.start2 -= extraLength, patch.utf8Start1 -= extraLength, patch.utf8Start2 -= extraLength, patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;\n  }\n  if (patch = patches[patches.length - 1], diffs = patch.diffs, diffs.length === 0 || diffs[diffs.length - 1][0] !== DIFF_EQUAL)\n    diffs.push([DIFF_EQUAL, nullPadding]), patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;\n  else if (paddingLength > diffs[diffs.length - 1][1].length) {\n    const extraLength = paddingLength - diffs[diffs.length - 1][1].length;\n    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength), patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;\n  }\n  return nullPadding;\n}\nfunction createPatchObject(start1, start2) {\n  return {\n    diffs: [],\n    start1,\n    start2,\n    utf8Start1: start1,\n    utf8Start2: start2,\n    length1: 0,\n    length2: 0,\n    utf8Length1: 0,\n    utf8Length2: 0\n  };\n}\nfunction splitMax(patches, margin = DEFAULT_MARGIN) {\n  const patchSize = MAX_BITS;\n  for (let x = 0; x < patches.length; x++) {\n    if (patches[x].length1 <= patchSize)\n      continue;\n    const bigpatch = patches[x];\n    patches.splice(x--, 1);\n    let start1 = bigpatch.start1, start2 = bigpatch.start2, preContext = \"\";\n    for (; bigpatch.diffs.length !== 0; ) {\n      const patch = createPatchObject(start1 - preContext.length, start2 - preContext.length);\n      let empty = !0;\n      if (preContext !== \"\") {\n        const precontextByteCount = countUtf8Bytes(preContext);\n        patch.length1 = preContext.length, patch.utf8Length1 = precontextByteCount, patch.length2 = preContext.length, patch.utf8Length2 = precontextByteCount, patch.diffs.push([DIFF_EQUAL, preContext]);\n      }\n      for (; bigpatch.diffs.length !== 0 && patch.length1 < patchSize - margin; ) {\n        const diffType = bigpatch.diffs[0][0];\n        let diffText = bigpatch.diffs[0][1], diffTextByteCount = countUtf8Bytes(diffText);\n        if (diffType === DIFF_INSERT) {\n          patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length;\n          const diff2 = bigpatch.diffs.shift();\n          diff2 && patch.diffs.push(diff2), empty = !1;\n        } else diffType === DIFF_DELETE && patch.diffs.length === 1 && patch.diffs[0][0] === DIFF_EQUAL && diffText.length > 2 * patchSize ? (patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, empty = !1, patch.diffs.push([diffType, diffText]), bigpatch.diffs.shift()) : (diffText = diffText.substring(0, patchSize - patch.length1 - margin), diffTextByteCount = countUtf8Bytes(diffText), patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, diffType === DIFF_EQUAL ? (patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length) : empty = !1, patch.diffs.push([diffType, diffText]), diffText === bigpatch.diffs[0][1] ? bigpatch.diffs.shift() : bigpatch.diffs[0][1] = bigpatch.diffs[0][1].substring(diffText.length));\n      }\n      preContext = diffText2(patch.diffs), preContext = preContext.substring(preContext.length - margin);\n      const postContext = diffText1(bigpatch.diffs).substring(0, margin), postContextByteCount = countUtf8Bytes(postContext);\n      postContext !== \"\" && (patch.length1 += postContext.length, patch.length2 += postContext.length, patch.utf8Length1 += postContextByteCount, patch.utf8Length2 += postContextByteCount, patch.diffs.length !== 0 && patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL ? patch.diffs[patch.diffs.length - 1][1] += postContext : patch.diffs.push([DIFF_EQUAL, postContext])), empty || patches.splice(++x, 0, patch);\n    }\n  }\n}\nfunction apply(patches, originalText, opts = {}) {\n  if (typeof patches == \"string\")\n    throw new Error(\"Patches must be an array - pass the patch to `parsePatch()` first\");\n  let text = originalText;\n  if (patches.length === 0)\n    return [text, []];\n  const parsed = adjustIndiciesToUcs2(patches, text, {\n    allowExceedingIndices: opts.allowExceedingIndices\n  }), margin = opts.margin || DEFAULT_MARGIN, deleteThreshold = opts.deleteThreshold || 0.4, nullPadding = addPadding(parsed, margin);\n  text = nullPadding + text + nullPadding, splitMax(parsed, margin);\n  let delta = 0;\n  const results = [];\n  for (let x = 0; x < parsed.length; x++) {\n    const expectedLoc = parsed[x].start2 + delta, text1 = diffText1(parsed[x].diffs);\n    let startLoc, endLoc = -1;\n    if (text1.length > MAX_BITS ? (startLoc = match(text, text1.substring(0, MAX_BITS), expectedLoc), startLoc !== -1 && (endLoc = match(\n      text,\n      text1.substring(text1.length - MAX_BITS),\n      expectedLoc + text1.length - MAX_BITS\n    ), (endLoc === -1 || startLoc >= endLoc) && (startLoc = -1))) : startLoc = match(text, text1, expectedLoc), startLoc === -1)\n      results[x] = !1, delta -= parsed[x].length2 - parsed[x].length1;\n    else {\n      results[x] = !0, delta = startLoc - expectedLoc;\n      let text2;\n      if (endLoc === -1 ? text2 = text.substring(startLoc, startLoc + text1.length) : text2 = text.substring(startLoc, endLoc + MAX_BITS), text1 === text2)\n        text = text.substring(0, startLoc) + diffText2(parsed[x].diffs) + text.substring(startLoc + text1.length);\n      else {\n        let diffs = diff(text1, text2, { checkLines: !1 });\n        if (text1.length > MAX_BITS && levenshtein(diffs) / text1.length > deleteThreshold)\n          results[x] = !1;\n        else {\n          diffs = cleanupSemanticLossless(diffs);\n          let index1 = 0, index2 = 0;\n          for (let y = 0; y < parsed[x].diffs.length; y++) {\n            const mod = parsed[x].diffs[y];\n            mod[0] !== DIFF_EQUAL && (index2 = xIndex(diffs, index1)), mod[0] === DIFF_INSERT ? text = text.substring(0, startLoc + index2) + mod[1] + text.substring(startLoc + index2) : mod[0] === DIFF_DELETE && (text = text.substring(0, startLoc + index2) + text.substring(startLoc + xIndex(diffs, index1 + mod[1].length))), mod[0] !== DIFF_DELETE && (index1 += mod[1].length);\n          }\n        }\n      }\n    }\n  }\n  return text = text.substring(nullPadding.length, text.length - nullPadding.length), [text, results];\n}\nvar __defProp = Object.defineProperty, __getOwnPropSymbols = Object.getOwnPropertySymbols, __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable, __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b))\n      __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);\n  return a;\n};\nconst DEFAULT_OPTS = {\n  margin: 4\n};\nfunction getDefaultOpts(opts = {}) {\n  return __spreadValues(__spreadValues({}, DEFAULT_OPTS), opts);\n}\nfunction make(a, b, options) {\n  if (typeof a == \"string\" && typeof b == \"string\") {\n    let diffs = diff(a, b, { checkLines: !0 });\n    return diffs.length > 2 && (diffs = cleanupSemantic(diffs), diffs = cleanupEfficiency(diffs)), _make(a, diffs, getDefaultOpts(options));\n  }\n  if (a && Array.isArray(a) && typeof b > \"u\")\n    return _make(diffText1(a), a, getDefaultOpts(options));\n  if (typeof a == \"string\" && b && Array.isArray(b))\n    return _make(a, b, getDefaultOpts(options));\n  throw new Error(\"Unknown call format to make()\");\n}\nfunction _make(textA, diffs, options) {\n  if (diffs.length === 0)\n    return [];\n  const patches = [];\n  let patch = createPatchObject(0, 0), patchDiffLength = 0, charCount1 = 0, charCount2 = 0, utf8Count1 = 0, utf8Count2 = 0, prepatchText = textA, postpatchText = textA;\n  for (let x = 0; x < diffs.length; x++) {\n    const currentDiff = diffs[x], [diffType, diffText] = currentDiff, diffTextLength = diffText.length, diffByteLength = countUtf8Bytes(diffText);\n    switch (!patchDiffLength && diffType !== DIFF_EQUAL && (patch.start1 = charCount1, patch.start2 = charCount2, patch.utf8Start1 = utf8Count1, patch.utf8Start2 = utf8Count2), diffType) {\n      case DIFF_INSERT:\n        patch.diffs[patchDiffLength++] = currentDiff, patch.length2 += diffTextLength, patch.utf8Length2 += diffByteLength, postpatchText = postpatchText.substring(0, charCount2) + diffText + postpatchText.substring(charCount2);\n        break;\n      case DIFF_DELETE:\n        patch.length1 += diffTextLength, patch.utf8Length1 += diffByteLength, patch.diffs[patchDiffLength++] = currentDiff, postpatchText = postpatchText.substring(0, charCount2) + postpatchText.substring(charCount2 + diffTextLength);\n        break;\n      case DIFF_EQUAL:\n        diffTextLength <= 2 * options.margin && patchDiffLength && diffs.length !== x + 1 ? (patch.diffs[patchDiffLength++] = currentDiff, patch.length1 += diffTextLength, patch.length2 += diffTextLength, patch.utf8Length1 += diffByteLength, patch.utf8Length2 += diffByteLength) : diffTextLength >= 2 * options.margin && patchDiffLength && (addContext(patch, prepatchText, options), patches.push(patch), patch = createPatchObject(-1, -1), patchDiffLength = 0, prepatchText = postpatchText, charCount1 = charCount2, utf8Count1 = utf8Count2);\n        break;\n      default:\n        throw new Error(\"Unknown diff type\");\n    }\n    diffType !== DIFF_INSERT && (charCount1 += diffTextLength, utf8Count1 += diffByteLength), diffType !== DIFF_DELETE && (charCount2 += diffTextLength, utf8Count2 += diffByteLength);\n  }\n  return patchDiffLength && (addContext(patch, prepatchText, options), patches.push(patch)), patches;\n}\nfunction addContext(patch, text, opts) {\n  if (text.length === 0)\n    return;\n  let pattern = text.substring(patch.start2, patch.start2 + patch.length1), padding = 0;\n  for (; text.indexOf(pattern) !== text.lastIndexOf(pattern) && pattern.length < MAX_BITS - opts.margin - opts.margin; )\n    padding += opts.margin, pattern = text.substring(patch.start2 - padding, patch.start2 + patch.length1 + padding);\n  padding += opts.margin;\n  let prefixStart = patch.start2 - padding;\n  prefixStart >= 1 && isLowSurrogate(text[prefixStart]) && prefixStart--;\n  const prefix = text.substring(prefixStart, patch.start2);\n  prefix && patch.diffs.unshift([DIFF_EQUAL, prefix]);\n  const prefixLength = prefix.length, prefixUtf8Length = countUtf8Bytes(prefix);\n  let suffixEnd = patch.start2 + patch.length1 + padding;\n  suffixEnd < text.length && isLowSurrogate(text[suffixEnd]) && suffixEnd++;\n  const suffix = text.substring(patch.start2 + patch.length1, suffixEnd);\n  suffix && patch.diffs.push([DIFF_EQUAL, suffix]);\n  const suffixLength = suffix.length, suffixUtf8Length = countUtf8Bytes(suffix);\n  patch.start1 -= prefixLength, patch.start2 -= prefixLength, patch.utf8Start1 -= prefixUtf8Length, patch.utf8Start2 -= prefixUtf8Length, patch.length1 += prefixLength + suffixLength, patch.length2 += prefixLength + suffixLength, patch.utf8Length1 += prefixUtf8Length + suffixUtf8Length, patch.utf8Length2 += prefixUtf8Length + suffixUtf8Length;\n}\nconst patchHeader = /^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$/;\nfunction parse(textline) {\n  if (!textline)\n    return [];\n  const patches = [], lines = textline.split(`\n`);\n  let textPointer = 0;\n  for (; textPointer < lines.length; ) {\n    const m = lines[textPointer].match(patchHeader);\n    if (!m)\n      throw new Error(`Invalid patch string: ${lines[textPointer]}`);\n    const patch = createPatchObject(toInt(m[1]), toInt(m[3]));\n    for (patches.push(patch), m[2] === \"\" ? (patch.start1--, patch.utf8Start1--, patch.length1 = 1, patch.utf8Length1 = 1) : m[2] === \"0\" ? (patch.length1 = 0, patch.utf8Length1 = 0) : (patch.start1--, patch.utf8Start1--, patch.utf8Length1 = toInt(m[2]), patch.length1 = patch.utf8Length1), m[4] === \"\" ? (patch.start2--, patch.utf8Start2--, patch.length2 = 1, patch.utf8Length2 = 1) : m[4] === \"0\" ? (patch.length2 = 0, patch.utf8Length2 = 0) : (patch.start2--, patch.utf8Start2--, patch.utf8Length2 = toInt(m[4]), patch.length2 = patch.utf8Length2), textPointer++; textPointer < lines.length; ) {\n      const currentLine = lines[textPointer], sign = currentLine.charAt(0);\n      if (sign === \"@\")\n        break;\n      if (sign === \"\") {\n        textPointer++;\n        continue;\n      }\n      let line;\n      try {\n        line = decodeURI(currentLine.slice(1));\n      } catch (ex) {\n        throw new Error(`Illegal escape in parse: ${currentLine}`);\n      }\n      const utf8Diff = countUtf8Bytes(line) - line.length;\n      if (sign === \"-\")\n        patch.diffs.push([DIFF_DELETE, line]), patch.length1 -= utf8Diff;\n      else if (sign === \"+\")\n        patch.diffs.push([DIFF_INSERT, line]), patch.length2 -= utf8Diff;\n      else if (sign === \" \")\n        patch.diffs.push([DIFF_EQUAL, line]), patch.length1 -= utf8Diff, patch.length2 -= utf8Diff;\n      else\n        throw new Error(`Invalid patch mode \"${sign}\" in: ${line}`);\n      textPointer++;\n    }\n  }\n  return patches;\n}\nfunction toInt(num) {\n  return parseInt(num, 10);\n}\nfunction stringify(patches) {\n  return patches.map(stringifyPatch).join(\"\");\n}\nfunction stringifyPatch(patch) {\n  const { utf8Length1, utf8Length2, utf8Start1, utf8Start2, diffs } = patch;\n  let coords1;\n  utf8Length1 === 0 ? coords1 = `${utf8Start1},0` : utf8Length1 === 1 ? coords1 = `${utf8Start1 + 1}` : coords1 = `${utf8Start1 + 1},${utf8Length1}`;\n  let coords2;\n  utf8Length2 === 0 ? coords2 = `${utf8Start2},0` : utf8Length2 === 1 ? coords2 = `${utf8Start2 + 1}` : coords2 = `${utf8Start2 + 1},${utf8Length2}`;\n  const text = [`@@ -${coords1} +${coords2} @@\n`];\n  let op;\n  for (let x = 0; x < diffs.length; x++) {\n    switch (diffs[x][0]) {\n      case DIFF_INSERT:\n        op = \"+\";\n        break;\n      case DIFF_DELETE:\n        op = \"-\";\n        break;\n      case DIFF_EQUAL:\n        op = \" \";\n        break;\n      default:\n        throw new Error(\"Unknown patch operation.\");\n    }\n    text[x + 1] = `${op + encodeURI(diffs[x][1])}\n`;\n  }\n  return text.join(\"\").replace(/%20/g, \" \");\n}\nexport {\n  DIFF_DELETE,\n  DIFF_EQUAL,\n  DIFF_INSERT,\n  adjustIndiciesToUcs2,\n  apply as applyPatches,\n  cleanupEfficiency,\n  cleanupSemantic,\n  diff as makeDiff,\n  make as makePatches,\n  match,\n  parse as parsePatch,\n  stringifyPatch,\n  stringify as stringifyPatches,\n  xIndex\n};\n//# sourceMappingURL=index.js.map\n","export default function throttle<T extends (...args: unknown[]) => void>(\n  callback: T,\n  wait: number,\n  immediate = false,\n): (...args: Parameters<T>) => void {\n  let timeout: ReturnType<typeof setTimeout> | null = null\n  let initialCall = true\n\n  return function (this: unknown, ...args: Parameters<T>): void {\n    const callNow = immediate && initialCall\n    const next = (): void => {\n      callback.apply(this, args)\n      timeout = null\n    }\n\n    if (callNow) {\n      initialCall = false\n      next()\n    }\n\n    if (!timeout) {\n      timeout = setTimeout(next, wait)\n    }\n  }\n}\n","export default function debounce<T extends (...args: unknown[]) => void>(\n  callback: T,\n  wait: number,\n): (...args: Parameters<T>) => void {\n  let timeout: ReturnType<typeof setTimeout> | undefined\n\n  return function (this: unknown, ...args: Parameters<T>): void {\n    clearTimeout(timeout)\n    timeout = setTimeout(() => callback.apply(this, args), wait)\n  }\n}\n","export default function normalizeContent(value: string | null = ''): string {\n  const normalized = (value ?? '').replace(/\\r\\n/g, '\\n')\n  return normalized\n}\n","/**\n * Generates a Bezier curve in SVG format\n */\nexport default function getCurve(\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n): string {\n  const w = endX - startX\n  const halfWidth = startX + w / 2\n\n  // now create the curve\n  // position it at the initial x,y coords\n  // This is of the form \"C M,N O,P Q,R\" where C is a directive for SVG (\"curveto\"),\n  // M,N are the first curve control point, O,P the second control point\n  // and Q,R are the final coords\n\n  return `M ${startX} ${startY} C ${halfWidth},${startY} ${halfWidth},${endY} ${endX},${endY}`\n}\n","export const DIFF_EQUAL = 0 as const\nexport const DIFF_DELETE = -1 as const\nexport const DIFF_INSERT = 1 as const\n\nexport const EDITOR_RIGHT = 'right' as const\nexport const EDITOR_LEFT = 'left' as const\n\nexport const RTL = 'rtl' as const\nexport const LTR = 'ltr' as const\n\nexport const SVG_NS = 'http://www.w3.org/2000/svg' as const\n\nexport const DIFF_GRANULARITY_SPECIFIC = 'specific' as const\nexport const DIFF_GRANULARITY_BROAD = 'broad' as const\n\nexport type EditorSide = typeof EDITOR_LEFT | typeof EDITOR_RIGHT\nexport type CopyDirection = typeof LTR | typeof RTL\nexport type DiffGranularity =\n  | typeof DIFF_GRANULARITY_SPECIFIC\n  | typeof DIFF_GRANULARITY_BROAD\n\n// Default export for backward compatibility\nexport default {\n  DIFF_EQUAL,\n  DIFF_DELETE,\n  DIFF_INSERT,\n  EDITOR_RIGHT,\n  EDITOR_LEFT,\n  RTL,\n  LTR,\n  SVG_NS,\n  DIFF_GRANULARITY_SPECIFIC,\n  DIFF_GRANULARITY_BROAD,\n} as const\n","import { EDITOR_LEFT, EDITOR_RIGHT, type EditorSide } from '../constants.js'\nimport type { AceDiffOptions } from '../types/options.js'\n\ninterface AceDiffInstance {\n  options: AceDiffOptions\n}\n\nexport default function getMode(\n  acediff: AceDiffInstance,\n  editor: EditorSide,\n): string | null {\n  let { mode } = acediff.options\n  if (editor === EDITOR_LEFT && acediff.options.left.mode !== null) {\n    mode = acediff.options.left.mode ?? mode\n  }\n  if (editor === EDITOR_RIGHT && acediff.options.right.mode !== null) {\n    mode = acediff.options.right.mode ?? mode\n  }\n  return mode\n}\n","import { EDITOR_LEFT, EDITOR_RIGHT, type EditorSide } from '../constants.js'\nimport type { AceDiffOptions } from '../types/options.js'\n\ninterface AceDiffInstance {\n  options: AceDiffOptions\n}\n\nexport default function getTheme(\n  acediff: AceDiffInstance,\n  editor: EditorSide,\n): string | null {\n  let { theme } = acediff.options\n  if (editor === EDITOR_LEFT && acediff.options.left.theme !== null) {\n    theme = acediff.options.left.theme ?? theme\n  }\n  if (editor === EDITOR_RIGHT && acediff.options.right.theme !== null) {\n    theme = acediff.options.right.theme ?? theme\n  }\n  return theme\n}\n","import type { EditorInstance } from '../types/ace.js'\n\nexport default function getLine(editor: EditorInstance, line: number): string {\n  return editor.ace.getSession().doc.getLine(line)\n}\n","import type { AceDiffOptions } from '../types/options.js'\n\ninterface AceDiffInstance {\n  options: AceDiffOptions\n}\n\nexport default function getEditorHeight(acediff: AceDiffInstance): number {\n  const leftId = acediff.options.left.id\n  if (!leftId) return 0\n  const element = document.getElementById(leftId)\n  return element?.offsetHeight ?? 0\n}\n","export interface ArrowInfo {\n  className: string\n  topOffset: number\n  tooltip: string\n  diffIndex: number\n  arrowContent: string\n}\n\nexport default function createArrow(info: ArrowInfo): HTMLDivElement {\n  const el = document.createElement('div')\n  const props: Record<string, string | number> = {\n    class: info.className,\n    style: `top:${info.topOffset}px`,\n    title: info.tooltip,\n    'data-diff-index': info.diffIndex,\n  }\n  for (const key in props) {\n    el.setAttribute(key, String(props[key]))\n  }\n  el.innerHTML = info.arrowContent\n  return el\n}\n","/**\n * Search for element in parent and create it if it can't be found\n * @param parent Parent HTMLElement\n * @param elClass Element class\n * @returns ID of the element\n */\nexport default function ensureElement(\n  parent: HTMLElement,\n  elClass: string,\n): string {\n  const guid = Math.random().toString(36).substr(2, 5)\n  const newId = `js-${elClass}-${guid}`\n\n  const currentEl = parent.querySelector<HTMLElement>(`.${elClass}`)\n  if (currentEl) {\n    currentEl.id = currentEl.id || newId\n    return currentEl.id\n  }\n\n  const el = document.createElement('div')\n  parent.appendChild(el)\n  el.className = elClass\n  el.id = newId\n  return el.id\n}\n","export default function on(\n  elSelector: string,\n  eventName: string,\n  selector: string,\n  fn: (event: Event) => void,\n): void {\n  const element =\n    elSelector === 'document'\n      ? document\n      : document.querySelector<HTMLElement>(elSelector)\n\n  if (!element) return\n\n  element.addEventListener(eventName, (event: Event) => {\n    const possibleTargets = element.querySelectorAll(selector)\n    const target = event.target as Node | null\n\n    for (let i = 0, l = possibleTargets.length; i < l; i += 1) {\n      let el: Node | null = target\n      const p = possibleTargets[i]\n\n      while (el && el !== element) {\n        if (el === p) {\n          fn.call(p, event)\n        }\n        el = el.parentNode\n      }\n    }\n  })\n}\n","/* eslint-disable no-console, @typescript-eslint/no-non-null-assertion */\nimport type { Ace } from 'ace-builds'\nimport { makeDiff, cleanupSemantic } from '@sanity/diff-match-patch'\nimport throttle from './helpers/throttle.js'\nimport debounce from './helpers/debounce.js'\nimport normalizeContent from './helpers/normalizeContent.js'\n\nimport getCurve from './visuals/getCurve.js'\nimport getMode from './visuals/getMode.js'\nimport getTheme from './visuals/getTheme.js'\nimport getLine from './visuals/getLine.js'\nimport getEditorHeight from './visuals/getEditorHeight.js'\nimport createArrow from './visuals/createArrow.js'\n\nimport ensureElement from './dom/ensureElement.js'\nimport query from './dom/query.js'\nimport C, {\n  DIFF_EQUAL,\n  DIFF_DELETE,\n  DIFF_INSERT,\n  EDITOR_LEFT,\n  EDITOR_RIGHT,\n  LTR,\n  RTL,\n  DIFF_GRANULARITY_BROAD,\n  DIFF_GRANULARITY_SPECIFIC,\n  type EditorSide,\n  type CopyDirection,\n} from './constants.js'\n\nimport type { AceDiffOptions, AceStatic } from './types/options.js'\nimport type { DiffInfo, CharRange } from './types/diff.js'\nimport type { EditorInstance, EditorState, AceRange } from './types/ace.js'\n\n// Range module placeholder\nlet Range: AceRange | null = null\n\nfunction getRangeModule(ace: AceStatic): AceRange | false {\n  if (ace.Range) {\n    return ace.Range\n  }\n\n  const requireFunc = ace.acequire || ace.require\n  if (requireFunc) {\n    return requireFunc('ace/range') as AceRange\n  }\n\n  return false\n}\n\n// Default options\nconst defaultOptions = {\n  ace: undefined as AceStatic | undefined,\n  mode: null as string | null,\n  theme: null as string | null,\n  element: null as HTMLElement | string | null,\n  diffGranularity: DIFF_GRANULARITY_BROAD as 'specific' | 'broad',\n  lockScrolling: true,\n  showDiffs: true,\n  showConnectors: true,\n  charDiffs: true,\n  maxDiffs: 5000,\n  left: {\n    id: null as string | null,\n    content: null as string | null,\n    mode: null as string | null,\n    theme: null as string | null,\n    editable: true,\n    copyLinkEnabled: true,\n  },\n  right: {\n    id: null as string | null,\n    content: null as string | null,\n    mode: null as string | null,\n    theme: null as string | null,\n    editable: true,\n    copyLinkEnabled: true,\n  },\n  classes: {\n    gutterID: 'acediff__gutter',\n    diff: 'acediff__diffLine',\n    diffChar: 'acediff__diffChar',\n    diffGutter: 'acediff__diffGutter',\n    connector: 'acediff__connector',\n    newCodeConnectorLink: 'acediff__newCodeConnector',\n    newCodeConnectorLinkContent: '&#8594;',\n    deletedCodeConnectorLink: 'acediff__deletedCodeConnector',\n    deletedCodeConnectorLinkContent: '&#8592;',\n    copyRightContainer: 'acediff__copy--right',\n    copyLeftContainer: 'acediff__copy--left',\n  },\n  connectorYOffset: 0,\n  onDiffReady: null as ((diffs: DiffInfo[]) => void) | null,\n}\n\nexport default class AceDiff {\n  options: AceDiffOptions\n  el!: HTMLElement\n  editors!: EditorState\n  diffs: DiffInfo[] = []\n  lineHeight = 0\n  gutterSVG: SVGSVGElement | null = null\n  gutterWidth = 0\n  gutterHeight = 0\n  copyLeftContainer: HTMLDivElement | null = null\n  copyRightContainer: HTMLDivElement | null = null\n  connectorYOffset = 0\n  private removeEventHandlers: (() => void) | null = null\n\n  constructor(options: Partial<AceDiffOptions> = {}) {\n    // Deep clone default options and merge with provided options\n    const clonedDefaults = JSON.parse(\n      JSON.stringify(defaultOptions),\n    ) as typeof defaultOptions\n\n    // Merge options\n    this.options = {\n      ...clonedDefaults,\n      ...options,\n      left: { ...clonedDefaults.left, ...options.left },\n      right: { ...clonedDefaults.right, ...options.right },\n      classes: { ...clonedDefaults.classes, ...options.classes },\n    }\n\n    const getDefaultAce = (): AceStatic | undefined =>\n      typeof window !== 'undefined'\n        ? (window as unknown as { ace?: AceStatic }).ace\n        : undefined\n\n    if (!this.options.ace) {\n      this.options.ace = getDefaultAce()\n    }\n\n    const { ace } = this.options\n\n    if (!ace) {\n      const errMessage =\n        'No ace editor found nor supplied - `options.ace` or `window.ace` is missing'\n      console.error(errMessage)\n      throw new Error(errMessage)\n    }\n\n    const rangeModule = getRangeModule(ace)\n    if (!rangeModule) {\n      const errMessage =\n        'Could not require Range module for Ace. Depends on your bundling strategy, but it usually comes with Ace itself. See https://ace.c9.io/api/range.html, open an issue on GitHub ace-diff/ace-diff'\n      console.error(errMessage)\n      throw new Error(errMessage)\n    }\n    Range = rangeModule\n\n    if (this.options.element === null) {\n      const errMessage =\n        'You need to specify an element for Ace-diff - `options.element` is missing'\n      console.error(errMessage)\n      throw new Error(errMessage)\n    }\n\n    if (this.options.element instanceof HTMLElement) {\n      this.el = this.options.element\n    } else {\n      const foundEl = document.body.querySelector<HTMLElement>(\n        this.options.element,\n      )\n      if (!foundEl) {\n        const errMessage = `Can't find the specified element ${this.options.element}`\n        console.error(errMessage)\n        throw new Error(errMessage)\n      }\n      this.el = foundEl\n    }\n\n    this.options.left.id = ensureElement(this.el, 'acediff__left')\n    this.options.classes.gutterID = ensureElement(this.el, 'acediff__gutter')\n    this.options.right.id = ensureElement(this.el, 'acediff__right')\n\n    this.el.innerHTML = `<div class=\"acediff acediff__wrap\">${this.el.innerHTML}</div>`\n\n    // instantiate the editors\n    this.editors = {\n      left: {\n        ace: ace.edit(this.options.left.id!),\n        markers: [],\n        lineLengths: [],\n        diffGutters: [],\n      },\n      right: {\n        ace: ace.edit(this.options.right.id!),\n        markers: [],\n        lineLengths: [],\n        diffGutters: [],\n      },\n      editorHeight: null,\n    }\n\n    // set up the editors\n    this.editors.left.ace.getSession().setMode(getMode(this, EDITOR_LEFT) ?? '')\n    this.editors.right.ace\n      .getSession()\n      .setMode(getMode(this, EDITOR_RIGHT) ?? '')\n    this.editors.left.ace.setReadOnly(!this.options.left.editable)\n    this.editors.right.ace.setReadOnly(!this.options.right.editable)\n    this.editors.left.ace.setShowFoldWidgets(false)\n    this.editors.right.ace.setShowFoldWidgets(false)\n    this.editors.left.ace.setTheme(getTheme(this, EDITOR_LEFT) ?? '')\n    this.editors.right.ace.setTheme(getTheme(this, EDITOR_RIGHT) ?? '')\n\n    this.editors.left.ace.setValue(\n      normalizeContent(this.options.left.content ?? null),\n      -1,\n    )\n    this.editors.right.ace.setValue(\n      normalizeContent(this.options.right.content ?? null),\n      -1,\n    )\n\n    // store the visible height of the editors\n    this.editors.editorHeight = getEditorHeight(this)\n\n    // The lineHeight is set to 0 initially and we need to wait for another tick\n    setTimeout(() => {\n      this.lineHeight = this.editors.left.ace.renderer.lineHeight\n      this.addEventHandlers()\n      this.createCopyContainers()\n      this.createGutter()\n      this.diff()\n    }, 1)\n  }\n\n  // Public methods\n  setOptions(options: Partial<AceDiffOptions>): void {\n    this.options = {\n      ...this.options,\n      ...options,\n      left: { ...this.options.left, ...options.left },\n      right: { ...this.options.right, ...options.right },\n      classes: { ...this.options.classes, ...options.classes },\n    }\n    this.diff()\n  }\n\n  getNumDiffs(): number {\n    return this.diffs.length\n  }\n\n  getEditors(): { left: Ace.Editor; right: Ace.Editor } {\n    return {\n      left: this.editors.left.ace,\n      right: this.editors.right.ace,\n    }\n  }\n\n  diff(): void {\n    const val1 = this.editors.left.ace.getSession().getValue()\n    const val2 = this.editors.right.ace.getSession().getValue()\n    const diff = cleanupSemantic(makeDiff(val2, val1))\n\n    this.editors.left.lineLengths = this.getLineLengths(this.editors.left)\n    this.editors.right.lineLengths = this.getLineLengths(this.editors.right)\n\n    const diffs: DiffInfo[] = []\n    const offset = { left: 0, right: 0 }\n\n    diff.forEach((chunk) => {\n      const chunkType = chunk[0]\n      const text = chunk[1]\n\n      if (text.length === 0) return\n\n      if (chunkType === DIFF_EQUAL) {\n        offset.left += text.length\n        offset.right += text.length\n      } else if (chunkType === DIFF_DELETE) {\n        diffs.push(\n          this.computeDiff(DIFF_DELETE, offset.left, offset.right, text),\n        )\n        offset.right += text.length\n      } else if (chunkType === DIFF_INSERT) {\n        diffs.push(\n          this.computeDiff(DIFF_INSERT, offset.left, offset.right, text),\n        )\n        offset.left += text.length\n      }\n    })\n\n    this.diffs = this.simplifyDiffs(diffs)\n\n    if (this.diffs.length > this.options.maxDiffs) {\n      return\n    }\n\n    this.clearDiffs()\n    this.decorate()\n\n    if (typeof this.options.onDiffReady === 'function') {\n      this.options.onDiffReady(this.diffs)\n    }\n  }\n\n  clear(): void {\n    this.clearDiffs()\n    this.clearGutter()\n    this.clearArrows()\n  }\n\n  destroy(): void {\n    const leftValue = this.editors.left.ace.getValue()\n    this.editors.left.ace.destroy()\n    let oldDiv = this.editors.left.ace.container\n    let newDiv = oldDiv.cloneNode(false) as HTMLElement\n    newDiv.textContent = leftValue\n    oldDiv.parentNode?.replaceChild(newDiv, oldDiv)\n\n    const rightValue = this.editors.right.ace.getValue()\n    this.editors.right.ace.destroy()\n    oldDiv = this.editors.right.ace.container\n    newDiv = oldDiv.cloneNode(false) as HTMLElement\n    newDiv.textContent = rightValue\n    oldDiv.parentNode?.replaceChild(newDiv, oldDiv)\n\n    const elementById = document.getElementById(this.options.classes.gutterID!)\n    if (elementById) {\n      elementById.innerHTML = ''\n    }\n    this.removeEventHandlers?.()\n  }\n\n  // Private methods\n  private addEventHandlers(): void {\n    let isSyncingScroll = false\n\n    const syncScroll = (\n      sourceEditor: EditorInstance,\n      targetEditor: EditorInstance,\n    ): void => {\n      if (!this.options.lockScrolling || isSyncingScroll) return\n\n      const sourceSession = sourceEditor.ace.getSession()\n      const targetSession = targetEditor.ace.getSession()\n\n      const sourceScrollTop = sourceSession.getScrollTop()\n      const sourceLineCount = sourceSession.getLength()\n      const sourceContentHeight = sourceLineCount * this.lineHeight\n      const sourceViewportHeight = (\n        sourceEditor.ace.renderer as unknown as {\n          $size: { scrollerHeight: number }\n        }\n      ).$size.scrollerHeight\n      const sourceMaxScroll = Math.max(\n        0,\n        sourceContentHeight - sourceViewportHeight,\n      )\n\n      const scrollRatio =\n        sourceMaxScroll > 0 ? sourceScrollTop / sourceMaxScroll : 0\n\n      const targetLineCount = targetSession.getLength()\n      const targetContentHeight = targetLineCount * this.lineHeight\n      const targetViewportHeight = (\n        targetEditor.ace.renderer as unknown as {\n          $size: { scrollerHeight: number }\n        }\n      ).$size.scrollerHeight\n      const targetMaxScroll = Math.max(\n        0,\n        targetContentHeight - targetViewportHeight,\n      )\n\n      const targetScrollTop = scrollRatio * targetMaxScroll\n\n      isSyncingScroll = true\n      targetSession.setScrollTop(targetScrollTop)\n      isSyncingScroll = false\n    }\n\n    this.editors.left.ace.getSession().on(\n      'changeScrollTop',\n      throttle(() => {\n        syncScroll(this.editors.left, this.editors.right)\n        this.updateGap()\n      }, 16),\n    )\n\n    this.editors.right.ace.getSession().on(\n      'changeScrollTop',\n      throttle(() => {\n        syncScroll(this.editors.right, this.editors.left)\n        this.updateGap()\n      }, 16),\n    )\n\n    const diffBound = this.diff.bind(this)\n    this.editors.left.ace.on('change', diffBound)\n    this.editors.right.ace.on('change', diffBound)\n\n    if (this.options.left.copyLinkEnabled) {\n      query(\n        `#${this.options.classes.gutterID}`,\n        'click',\n        `.${this.options.classes.newCodeConnectorLink}`,\n        (e) => this.copy(e, LTR),\n      )\n    }\n\n    if (this.options.right.copyLinkEnabled) {\n      query(\n        `#${this.options.classes.gutterID}`,\n        'click',\n        `.${this.options.classes.deletedCodeConnectorLink}`,\n        (e) => this.copy(e, RTL),\n      )\n    }\n\n    const onResize = debounce(() => {\n      const leftEl = document.getElementById(this.options.left.id!)\n      if (leftEl) {\n        ;(this.editors as { availableHeight?: number }).availableHeight =\n          leftEl.offsetHeight\n      }\n      this.diff()\n    }, 250)\n\n    window.addEventListener('resize', onResize)\n    this.removeEventHandlers = () => {\n      window.removeEventListener('resize', onResize)\n    }\n  }\n\n  private copy(e: Event, dir: CopyDirection): void {\n    const target = e.target as HTMLElement\n    const diffIndex = parseInt(\n      target.getAttribute('data-diff-index') ?? '0',\n      10,\n    )\n    const diff = this.diffs[diffIndex]\n    if (!diff) return\n\n    // Don't allow copying into a non-editable editor\n    if (dir === LTR && !this.options.right.editable) return\n    if (dir === RTL && !this.options.left.editable) return\n\n    let sourceEditor: EditorInstance\n    let targetEditor: EditorInstance\n    let sourceStartOffset: number\n    let sourceEndOffset: number\n    let targetStartOffset: number\n    let targetEndOffset: number\n\n    if (dir === LTR) {\n      sourceEditor = this.editors.left\n      targetEditor = this.editors.right\n      sourceStartOffset = diff.leftStartOffset\n      sourceEndOffset = diff.leftEndOffset\n      targetStartOffset = diff.rightStartOffset\n      targetEndOffset = diff.rightEndOffset\n    } else {\n      sourceEditor = this.editors.right\n      targetEditor = this.editors.left\n      sourceStartOffset = diff.rightStartOffset\n      sourceEndOffset = diff.rightEndOffset\n      targetStartOffset = diff.leftStartOffset\n      targetEndOffset = diff.leftEndOffset\n    }\n\n    const sourceValue = sourceEditor.ace.getValue()\n    const contentToInsert = sourceValue.substring(\n      sourceStartOffset,\n      sourceEndOffset,\n    )\n\n    const targetDoc = targetEditor.ace.getSession().doc\n    const startPos = targetDoc.indexToPosition(targetStartOffset, 0)\n    const endPos = targetDoc.indexToPosition(targetEndOffset, 0)\n\n    const h = targetEditor.ace.getSession().getScrollTop()\n\n    if (Range) {\n      targetEditor.ace\n        .getSession()\n        .replace(\n          new Range(startPos.row, startPos.column, endPos.row, endPos.column),\n          contentToInsert,\n        )\n    }\n    targetEditor.ace.getSession().setScrollTop(parseInt(String(h), 10))\n\n    this.diff()\n  }\n\n  private getLineLengths(editor: EditorInstance): number[] {\n    const lines = editor.ace.getSession().doc.getAllLines()\n    return lines.map((line: string) => line.length + 1)\n  }\n\n  private showDiff(\n    editor: EditorSide,\n    startLine: number,\n    endLine: number,\n    chars: CharRange[],\n    className: string,\n  ): void {\n    const editorInstance = this.editors[editor]\n    let actualEndLine = endLine\n\n    if (actualEndLine < startLine) {\n      actualEndLine = startLine\n    }\n\n    const classNames = `${className} ${\n      actualEndLine > startLine ? 'lines' : 'targetOnly'\n    } ${editor}`\n\n    let markerEndLine = actualEndLine\n    if (markerEndLine > startLine) {\n      markerEndLine -= 1\n    }\n\n    if (Range) {\n      editorInstance.markers.push(\n        editorInstance.ace.session.addMarker(\n          new Range(startLine, 0, markerEndLine, 1),\n          classNames,\n          'fullLine',\n        ),\n      )\n    }\n\n    if (this.options.charDiffs && chars && chars.length > 0) {\n      const charClassName = `${this.options.classes.diffChar} ${editor}`\n      chars.forEach((char) => {\n        if (Range) {\n          editorInstance.markers.push(\n            editorInstance.ace.session.addMarker(\n              new Range(char.lineStart, char.start, char.lineEnd - 1, char.end),\n              charClassName,\n              'text',\n            ),\n          )\n        }\n      })\n    }\n\n    const gutterClassName = `${this.options.classes.diffGutter} ${editor}`\n    for (let line = startLine; line < actualEndLine; line += 1) {\n      editorInstance.ace.session.addGutterDecoration(line, gutterClassName)\n      editorInstance.diffGutters.push({ line, className: gutterClassName })\n    }\n  }\n\n  private updateGap(): void {\n    this.clearDiffs()\n    this.decorate()\n    this.positionCopyContainers()\n  }\n\n  private clearDiffs(): void {\n    this.editors.left.markers.forEach((marker) => {\n      this.editors.left.ace.getSession().removeMarker(marker)\n    })\n    this.editors.right.markers.forEach((marker) => {\n      this.editors.right.ace.getSession().removeMarker(marker)\n    })\n    this.editors.left.markers = []\n    this.editors.right.markers = []\n\n    this.editors.left.diffGutters.forEach((gutter) => {\n      this.editors.left.ace.session.removeGutterDecoration(\n        gutter.line,\n        gutter.className,\n      )\n    })\n    this.editors.right.diffGutters.forEach((gutter) => {\n      this.editors.right.ace.session.removeGutterDecoration(\n        gutter.line,\n        gutter.className,\n      )\n    })\n    this.editors.left.diffGutters = []\n    this.editors.right.diffGutters = []\n  }\n\n  private addConnector(\n    leftStartLine: number,\n    leftEndLine: number,\n    rightStartLine: number,\n    rightEndLine: number,\n  ): void {\n    const leftScrollTop = this.editors.left.ace.getSession().getScrollTop()\n    const rightScrollTop = this.editors.right.ace.getSession().getScrollTop()\n\n    this.connectorYOffset = 1\n\n    const p1_x = -1\n    const p1_y = leftStartLine * this.lineHeight - leftScrollTop + 0.5\n    const p2_x = this.gutterWidth + 1\n    const p2_y = rightStartLine * this.lineHeight - rightScrollTop + 0.5\n    const p3_x = -1\n    const p3_y =\n      leftEndLine * this.lineHeight -\n      leftScrollTop +\n      this.connectorYOffset +\n      0.5\n    const p4_x = this.gutterWidth + 1\n    const p4_y =\n      rightEndLine * this.lineHeight -\n      rightScrollTop +\n      this.connectorYOffset +\n      0.5\n\n    const curve1 = getCurve(p1_x, p1_y, p2_x, p2_y)\n    const curve2 = getCurve(p4_x, p4_y, p3_x, p3_y)\n\n    const verticalLine1 = `L${p2_x},${p2_y} ${p4_x},${p4_y}`\n    const verticalLine2 = `L${p3_x},${p3_y} ${p1_x},${p1_y}`\n    const d = `${curve1} ${verticalLine1} ${curve2} ${verticalLine2}`\n\n    const el = document.createElementNS(C.SVG_NS, 'path')\n    el.setAttribute('d', d)\n    el.setAttribute('class', this.options.classes.connector ?? '')\n    this.gutterSVG?.appendChild(el)\n  }\n\n  private addCopyArrows(info: DiffInfo, diffIndex: number): void {\n    // \"Copy to right\" arrow: only show if left has content to copy,\n    // left.copyLinkEnabled is true, AND the right editor is editable\n    if (\n      info.leftEndLine > info.leftStartLine &&\n      this.options.left.copyLinkEnabled &&\n      this.options.right.editable\n    ) {\n      const arrow = createArrow({\n        className: this.options.classes.newCodeConnectorLink ?? '',\n        topOffset: info.leftStartLine * this.lineHeight,\n        tooltip: 'Copy to right',\n        diffIndex,\n        arrowContent: this.options.classes.newCodeConnectorLinkContent ?? '',\n      })\n      this.copyRightContainer?.appendChild(arrow)\n    }\n\n    // \"Copy to left\" arrow: only show if right has content to copy,\n    // right.copyLinkEnabled is true, AND the left editor is editable\n    if (\n      info.rightEndLine > info.rightStartLine &&\n      this.options.right.copyLinkEnabled &&\n      this.options.left.editable\n    ) {\n      const arrow = createArrow({\n        className: this.options.classes.deletedCodeConnectorLink ?? '',\n        topOffset: info.rightStartLine * this.lineHeight,\n        tooltip: 'Copy to left',\n        diffIndex,\n        arrowContent:\n          this.options.classes.deletedCodeConnectorLinkContent ?? '',\n      })\n      this.copyLeftContainer?.appendChild(arrow)\n    }\n  }\n\n  private positionCopyContainers(): void {\n    const leftTopOffset = this.editors.left.ace.getSession().getScrollTop()\n    const rightTopOffset = this.editors.right.ace.getSession().getScrollTop()\n\n    if (this.copyRightContainer) {\n      this.copyRightContainer.style.cssText = `top: ${-leftTopOffset}px`\n    }\n    if (this.copyLeftContainer) {\n      this.copyLeftContainer.style.cssText = `top: ${-rightTopOffset}px`\n    }\n  }\n\n  private computeDiff(\n    diffType: number,\n    offsetLeft: number,\n    offsetRight: number,\n    diffText: string,\n  ): DiffInfo {\n    let lineInfo: Partial<DiffInfo> = {}\n\n    if (diffType === DIFF_INSERT) {\n      const info = this.getSingleDiffInfo(\n        this.editors.left,\n        offsetLeft,\n        diffText,\n      )\n      const currentLineOtherEditor = this.getLineForCharPosition(\n        this.editors.right,\n        offsetRight,\n      )\n      const numCharsOnLineOtherEditor = this.getCharsOnLine(\n        this.editors.right,\n        currentLineOtherEditor,\n      )\n      const numCharsOnLeftEditorStartLine = this.getCharsOnLine(\n        this.editors.left,\n        info.startLine,\n      )\n\n      const rightStartLine = currentLineOtherEditor\n      const sameLineInsert = info.startLine === info.endLine\n\n      let numRows = 0\n      if (\n        (info.startChar > 0 ||\n          (sameLineInsert &&\n            diffText.length < numCharsOnLeftEditorStartLine)) &&\n        numCharsOnLineOtherEditor > 0 &&\n        info.startChar < numCharsOnLeftEditorStartLine\n      ) {\n        numRows++\n      }\n\n      lineInfo = {\n        leftStartLine: info.startLine,\n        leftEndLine: info.endLine + 1,\n        rightStartLine,\n        rightEndLine: rightStartLine + numRows,\n        leftStartOffset: offsetLeft,\n        leftEndOffset: offsetLeft + diffText.length,\n        rightStartOffset: offsetRight,\n        rightEndOffset: offsetRight,\n        leftStartChar: info.startChar,\n        leftEndChar: info.endChar,\n      }\n    } else {\n      const info = this.getSingleDiffInfo(\n        this.editors.right,\n        offsetRight,\n        diffText,\n      )\n      const currentLineOtherEditor = this.getLineForCharPosition(\n        this.editors.left,\n        offsetLeft,\n      )\n      const numCharsOnLineOtherEditor = this.getCharsOnLine(\n        this.editors.left,\n        currentLineOtherEditor,\n      )\n      const numCharsOnRightEditorStartLine = this.getCharsOnLine(\n        this.editors.right,\n        info.startLine,\n      )\n\n      const leftStartLine = currentLineOtherEditor\n      const sameLineInsert = info.startLine === info.endLine\n\n      let numRows = 0\n      if (\n        (info.startChar > 0 ||\n          (sameLineInsert &&\n            diffText.length < numCharsOnRightEditorStartLine)) &&\n        numCharsOnLineOtherEditor > 0 &&\n        info.startChar < numCharsOnRightEditorStartLine\n      ) {\n        numRows++\n      }\n\n      lineInfo = {\n        leftStartLine,\n        leftEndLine: leftStartLine + numRows,\n        rightStartLine: info.startLine,\n        rightEndLine: info.endLine + 1,\n        leftStartOffset: offsetLeft,\n        leftEndOffset: offsetLeft,\n        rightStartOffset: offsetRight,\n        rightEndOffset: offsetRight + diffText.length,\n        rightStartChar: info.startChar,\n        rightEndChar: info.endChar,\n      }\n    }\n\n    return lineInfo as DiffInfo\n  }\n\n  private getSingleDiffInfo(\n    editor: EditorInstance,\n    offset: number,\n    diffString: string,\n  ): {\n    startLine: number\n    startChar: number\n    endLine: number\n    endChar: number\n  } {\n    const info = {\n      startLine: 0,\n      startChar: 0,\n      endLine: 0,\n      endChar: 0,\n    }\n    const endCharNum = offset + diffString.length\n    let runningTotal = 0\n    let startLineSet = false\n    let endLineSet = false\n\n    editor.lineLengths.forEach((lineLength, lineIndex) => {\n      runningTotal += lineLength\n\n      if (!startLineSet && offset < runningTotal) {\n        info.startLine = lineIndex\n        info.startChar = offset - runningTotal + lineLength\n        startLineSet = true\n      }\n\n      if (!endLineSet && endCharNum <= runningTotal) {\n        info.endLine = lineIndex\n        info.endChar = endCharNum - runningTotal + lineLength\n        endLineSet = true\n      }\n    })\n\n    if (\n      info.startChar > 0 &&\n      this.getCharsOnLine(editor, info.startLine) === info.startChar\n    ) {\n      info.startLine++\n      info.startChar = 0\n    }\n\n    if (info.endChar === 0) {\n      info.endLine--\n    }\n\n    const endsWithNewline = /\\n$/.test(diffString)\n    if (info.startChar > 0 && endsWithNewline) {\n      info.endLine++\n    }\n\n    return info\n  }\n\n  private getCharsOnLine(editor: EditorInstance, line: number): number {\n    return getLine(editor, line).length\n  }\n\n  private getLineForCharPosition(\n    editor: EditorInstance,\n    offsetChars: number,\n  ): number {\n    const lines: string[] = editor.ace.getSession().doc.getAllLines()\n    let foundLine = 0\n    let runningTotal = 0\n\n    for (let i = 0; i < lines.length; i += 1) {\n      const line = lines[i]\n      if (line !== undefined) {\n        runningTotal += line.length + 1\n      }\n      if (offsetChars <= runningTotal) {\n        foundLine = i\n        if (offsetChars === runningTotal && i < lines.length - 1) {\n          foundLine += 1\n        }\n        break\n      }\n    }\n\n    if (runningTotal >= editor.ace.getSession().getValue().length) {\n      foundLine += 1\n    }\n\n    return foundLine\n  }\n\n  private createGutter(): void {\n    const gutterEl = document.getElementById(this.options.classes.gutterID!)\n    if (!gutterEl) return\n\n    this.gutterHeight = gutterEl.clientHeight\n    this.gutterWidth = gutterEl.clientWidth\n\n    const leftHeight = this.getTotalHeight(EDITOR_LEFT)\n    const rightHeight = this.getTotalHeight(EDITOR_RIGHT)\n    const height = Math.max(leftHeight, rightHeight, this.gutterHeight)\n\n    this.gutterSVG = document.createElementNS(C.SVG_NS, 'svg')\n    this.gutterSVG.setAttribute('width', String(this.gutterWidth))\n    this.gutterSVG.setAttribute('height', String(height))\n\n    gutterEl.appendChild(this.gutterSVG)\n  }\n\n  private getTotalHeight(editor: EditorSide): number {\n    const ed = editor === EDITOR_LEFT ? this.editors.left : this.editors.right\n    return ed.ace.getSession().getLength() * this.lineHeight\n  }\n\n  private createCopyContainers(): void {\n    this.copyRightContainer = document.createElement('div')\n    this.copyRightContainer.setAttribute(\n      'class',\n      this.options.classes.copyRightContainer ?? '',\n    )\n    this.copyLeftContainer = document.createElement('div')\n    this.copyLeftContainer.setAttribute(\n      'class',\n      this.options.classes.copyLeftContainer ?? '',\n    )\n\n    const gutterEl = document.getElementById(this.options.classes.gutterID!)\n    if (gutterEl) {\n      gutterEl.appendChild(this.copyRightContainer)\n      gutterEl.appendChild(this.copyLeftContainer)\n    }\n  }\n\n  private clearGutter(): void {\n    const gutterEl = document.getElementById(this.options.classes.gutterID!)\n    if (gutterEl && this.gutterSVG) {\n      gutterEl.removeChild(this.gutterSVG)\n    }\n    this.createGutter()\n  }\n\n  private clearArrows(): void {\n    if (this.copyLeftContainer) {\n      this.copyLeftContainer.innerHTML = ''\n    }\n    if (this.copyRightContainer) {\n      this.copyRightContainer.innerHTML = ''\n    }\n  }\n\n  private simplifyDiffs(diffs: DiffInfo[]): DiffInfo[] {\n    const groupedDiffs: DiffInfo[] = []\n\n    const compare = (val: number): boolean =>\n      this.options.diffGranularity === DIFF_GRANULARITY_SPECIFIC\n        ? val < 1\n        : val <= 1\n\n    const createDiffWithChars = (diff: Partial<DiffInfo>): DiffInfo => {\n      const newDiff: DiffInfo = {\n        ...diff,\n        leftChars: [],\n        rightChars: [],\n      } as DiffInfo\n\n      if (diff.leftEndChar !== undefined) {\n        newDiff.leftChars.push({\n          start: diff.leftStartChar ?? 0,\n          end: diff.leftEndChar,\n          lineStart: diff.leftStartLine ?? 0,\n          lineEnd: diff.leftEndLine ?? 0,\n        })\n      }\n      if (diff.rightEndChar !== undefined) {\n        newDiff.rightChars.push({\n          start: diff.rightStartChar ?? 0,\n          end: diff.rightEndChar,\n          lineStart: diff.rightStartLine ?? 0,\n          lineEnd: diff.rightEndLine ?? 0,\n        })\n      }\n      return newDiff\n    }\n\n    diffs.forEach((diff, index) => {\n      if (index === 0) {\n        groupedDiffs.push(createDiffWithChars(diff))\n        return\n      }\n\n      let isGrouped = false\n      for (let i = 0; i < groupedDiffs.length; i += 1) {\n        if (\n          compare(\n            Math.abs(diff.leftStartLine - groupedDiffs[i]!.leftEndLine),\n          ) &&\n          compare(Math.abs(diff.rightStartLine - groupedDiffs[i]!.rightEndLine))\n        ) {\n          groupedDiffs[i]!.leftStartLine = Math.min(\n            diff.leftStartLine,\n            groupedDiffs[i]!.leftStartLine,\n          )\n          groupedDiffs[i]!.rightStartLine = Math.min(\n            diff.rightStartLine,\n            groupedDiffs[i]!.rightStartLine,\n          )\n          groupedDiffs[i]!.leftEndLine = Math.max(\n            diff.leftEndLine,\n            groupedDiffs[i]!.leftEndLine,\n          )\n          groupedDiffs[i]!.rightEndLine = Math.max(\n            diff.rightEndLine,\n            groupedDiffs[i]!.rightEndLine,\n          )\n          groupedDiffs[i]!.leftStartOffset = Math.min(\n            diff.leftStartOffset,\n            groupedDiffs[i]!.leftStartOffset,\n          )\n          groupedDiffs[i]!.leftEndOffset = Math.max(\n            diff.leftEndOffset,\n            groupedDiffs[i]!.leftEndOffset,\n          )\n          groupedDiffs[i]!.rightStartOffset = Math.min(\n            diff.rightStartOffset,\n            groupedDiffs[i]!.rightStartOffset,\n          )\n          groupedDiffs[i]!.rightEndOffset = Math.max(\n            diff.rightEndOffset,\n            groupedDiffs[i]!.rightEndOffset,\n          )\n\n          if (diff.leftEndChar !== undefined) {\n            groupedDiffs[i]!.leftChars.push({\n              start: diff.leftStartChar ?? 0,\n              end: diff.leftEndChar,\n              lineStart: diff.leftStartLine,\n              lineEnd: diff.leftEndLine,\n            })\n          }\n          if (diff.rightEndChar !== undefined) {\n            groupedDiffs[i]!.rightChars.push({\n              start: diff.rightStartChar ?? 0,\n              end: diff.rightEndChar,\n              lineStart: diff.rightStartLine,\n              lineEnd: diff.rightEndLine,\n            })\n          }\n          isGrouped = true\n          break\n        }\n      }\n\n      if (!isGrouped) {\n        groupedDiffs.push(createDiffWithChars(diff))\n      }\n    })\n\n    return groupedDiffs.filter(\n      (diff) =>\n        !(\n          diff.leftStartLine === diff.leftEndLine &&\n          diff.rightStartLine === diff.rightEndLine\n        ),\n    )\n  }\n\n  private decorate(): void {\n    this.clearGutter()\n    this.clearArrows()\n\n    this.diffs.forEach((info, diffIndex) => {\n      if (this.options.showDiffs) {\n        this.showDiff(\n          EDITOR_LEFT,\n          info.leftStartLine,\n          info.leftEndLine,\n          info.leftChars,\n          this.options.classes.diff ?? '',\n        )\n        this.showDiff(\n          EDITOR_RIGHT,\n          info.rightStartLine,\n          info.rightEndLine,\n          info.rightChars,\n          this.options.classes.diff ?? '',\n        )\n\n        if (this.options.showConnectors) {\n          this.addConnector(\n            info.leftStartLine,\n            info.leftEndLine,\n            info.rightStartLine,\n            info.rightEndLine,\n          )\n        }\n        this.addCopyArrows(info, diffIndex)\n      }\n    })\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}