ace-diff
Version:
A diff/merging wrapper for Ace Editor built on google-diff-match-patch
1 lines • 119 kB
Source Map (JSON)
{"version":3,"file":"index.mjs","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