mito-ai 0.1.50__py3-none-any.whl

mito_ai-0.1.50.data/data/share/jupyter/labextensions/mito_ai/static/vendors-node_modules_vscode-diff_dist_index_js.ea55f1f9346638aafbcf.js

@@ -0,0 +1,4859 @@
+"use strict";
+(self["webpackChunkmito_ai"] = self["webpackChunkmito_ai"] || []).push([["vendors-node_modules_vscode-diff_dist_index_js"],{
+
+/***/ "./node_modules/vscode-diff/dist/index.js":
+/*!************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/index.js ***!
+  \************************************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(/*! ./vs/editor/common/diff/linesDiffComputer */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/linesDiffComputer.js"), exports);
+__exportStar(__webpack_require__(/*! ./vs/base/common/diff/diff */ "./node_modules/vscode-diff/dist/vs/base/common/diff/diff.js"), exports);
+__exportStar(__webpack_require__(/*! ./vs/base/common/diff/diffChange */ "./node_modules/vscode-diff/dist/vs/base/common/diff/diffChange.js"), exports);
+__exportStar(__webpack_require__(/*! ./vs/editor/common/diff/legacyLinesDiffComputer */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/legacyLinesDiffComputer.js"), exports);
+__exportStar(__webpack_require__(/*! ./vs/editor/common/diff/advancedLinesDiffComputer */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/advancedLinesDiffComputer.js"), exports);
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/arrays.js":
+/*!****************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/arrays.js ***!
+  \****************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CallbackIterable = exports.reverseOrder = exports.numberComparator = exports.compareBy = exports.CompareResult = exports.findLastIndex = exports.equals = void 0;
+function equals(one, other, itemEquals = (a, b) => a === b) {
+    if (one === other) {
+        return true;
+    }
+    if (!one || !other) {
+        return false;
+    }
+    if (one.length !== other.length) {
+        return false;
+    }
+    for (let i = 0, len = one.length; i < len; i++) {
+        if (!itemEquals(one[i], other[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equals = equals;
+function findLastIndex(array, fn) {
+    for (let i = array.length - 1; i >= 0; i--) {
+        const element = array[i];
+        if (fn(element)) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.findLastIndex = findLastIndex;
+var CompareResult;
+(function (CompareResult) {
+    function isLessThan(result) {
+        return result < 0;
+    }
+    CompareResult.isLessThan = isLessThan;
+    function isLessThanOrEqual(result) {
+        return result <= 0;
+    }
+    CompareResult.isLessThanOrEqual = isLessThanOrEqual;
+    function isGreaterThan(result) {
+        return result > 0;
+    }
+    CompareResult.isGreaterThan = isGreaterThan;
+})(CompareResult || (exports.CompareResult = CompareResult = {}));
+function compareBy(selector, comparator) {
+    return (a, b) => comparator(selector(a), selector(b));
+}
+exports.compareBy = compareBy;
+/**
+ * The natural order on numbers.
+*/
+const numberComparator = (a, b) => a - b;
+exports.numberComparator = numberComparator;
+function reverseOrder(comparator) {
+    return (a, b) => -comparator(a, b);
+}
+exports.reverseOrder = reverseOrder;
+/**
+ * This class is faster than an iterator and array for lazy computed data.
+*/
+class CallbackIterable {
+    constructor(
+    /**
+     * Calls the callback for every item.
+     * Stops when the callback returns false.
+    */
+    iterate) {
+        this.iterate = iterate;
+    }
+    forEach(handler) {
+        this.iterate(item => { handler(item); return true; });
+    }
+    toArray() {
+        const result = [];
+        this.iterate(item => { result.push(item); return true; });
+        return result;
+    }
+    filter(predicate) {
+        return new CallbackIterable(cb => this.iterate(item => predicate(item) ? cb(item) : true));
+    }
+    map(mapFn) {
+        return new CallbackIterable(cb => this.iterate(item => cb(mapFn(item))));
+    }
+    some(predicate) {
+        let result = false;
+        this.iterate(item => { result = predicate(item); return !result; });
+        return result;
+    }
+    findFirst(predicate) {
+        let result;
+        this.iterate(item => {
+            if (predicate(item)) {
+                result = item;
+                return false;
+            }
+            return true;
+        });
+        return result;
+    }
+    findLast(predicate) {
+        let result;
+        this.iterate(item => {
+            if (predicate(item)) {
+                result = item;
+            }
+            return true;
+        });
+        return result;
+    }
+    findLastMaxBy(comparator) {
+        let result;
+        let first = true;
+        this.iterate(item => {
+            if (first || CompareResult.isGreaterThan(comparator(item, result))) {
+                first = false;
+                result = item;
+            }
+            return true;
+        });
+        return result;
+    }
+}
+exports.CallbackIterable = CallbackIterable;
+CallbackIterable.empty = new CallbackIterable(_callback => { });
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/assert.js":
+/*!****************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/assert.js ***!
+  \****************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.checkAdjacentItems = exports.assertFn = void 0;
+const errors_1 = __webpack_require__(/*! ./errors */ "./node_modules/vscode-diff/dist/vs/base/common/errors.js");
+/**
+ * condition must be side-effect free!
+ */
+function assertFn(condition) {
+    if (!condition()) {
+        // eslint-disable-next-line no-debugger
+        debugger;
+        // Reevaluate `condition` again to make debugging easier
+        condition();
+        (0, errors_1.onUnexpectedError)(new errors_1.BugIndicatingError('Assertion Failed'));
+    }
+}
+exports.assertFn = assertFn;
+function checkAdjacentItems(items, predicate) {
+    let i = 0;
+    while (i < items.length - 1) {
+        const a = items[i];
+        const b = items[i + 1];
+        if (!predicate(a, b)) {
+            return false;
+        }
+        i++;
+    }
+    return true;
+}
+exports.checkAdjacentItems = checkAdjacentItems;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/collections.js":
+/*!*********************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/collections.js ***!
+  \*********************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SetMap = void 0;
+class SetMap {
+    constructor() {
+        this.map = new Map();
+    }
+    add(key, value) {
+        let values = this.map.get(key);
+        if (!values) {
+            values = new Set();
+            this.map.set(key, values);
+        }
+        values.add(value);
+    }
+    delete(key, value) {
+        const values = this.map.get(key);
+        if (!values) {
+            return;
+        }
+        values.delete(value);
+        if (values.size === 0) {
+            this.map.delete(key);
+        }
+    }
+    forEach(key, fn) {
+        const values = this.map.get(key);
+        if (!values) {
+            return;
+        }
+        values.forEach(fn);
+    }
+    get(key) {
+        const values = this.map.get(key);
+        if (!values) {
+            return new Set();
+        }
+        return values;
+    }
+}
+exports.SetMap = SetMap;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/diff/diff.js":
+/*!*******************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/diff/diff.js ***!
+  \*******************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.LcsDiff = exports.stringDiff = exports.StringDiffSequence = void 0;
+const hash_1 = __webpack_require__(/*! ../hash */ "./node_modules/vscode-diff/dist/vs/base/common/hash.js");
+const diffChange_1 = __webpack_require__(/*! ./diffChange */ "./node_modules/vscode-diff/dist/vs/base/common/diff/diffChange.js");
+class StringDiffSequence {
+    constructor(source) {
+        this.source = source;
+    }
+    getElements() {
+        const source = this.source;
+        const characters = new Int32Array(source.length);
+        for (let i = 0, len = source.length; i < len; i++) {
+            characters[i] = source.charCodeAt(i);
+        }
+        return characters;
+    }
+}
+exports.StringDiffSequence = StringDiffSequence;
+function stringDiff(original, modified, pretty) {
+    return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes;
+}
+exports.stringDiff = stringDiff;
+//
+// The code below has been ported from a C# implementation in VS
+//
+class Debug {
+    static Assert(condition, message) {
+        if (!condition) {
+            throw new Error(message);
+        }
+    }
+}
+class MyArray {
+    /**
+     * Copies a range of elements from an Array starting at the specified source index and pastes
+     * them to another Array starting at the specified destination index. The length and the indexes
+     * are specified as 64-bit integers.
+     * sourceArray:
+     *		The Array that contains the data to copy.
+     * sourceIndex:
+     *		A 64-bit integer that represents the index in the sourceArray at which copying begins.
+     * destinationArray:
+     *		The Array that receives the data.
+     * destinationIndex:
+     *		A 64-bit integer that represents the index in the destinationArray at which storing begins.
+     * length:
+     *		A 64-bit integer that represents the number of elements to copy.
+     */
+    static Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {
+        for (let i = 0; i < length; i++) {
+            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
+        }
+    }
+    static Copy2(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {
+        for (let i = 0; i < length; i++) {
+            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
+        }
+    }
+}
+/**
+ * A utility class which helps to create the set of DiffChanges from
+ * a difference operation. This class accepts original DiffElements and
+ * modified DiffElements that are involved in a particular change. The
+ * MarkNextChange() method can be called to mark the separation between
+ * distinct changes. At the end, the Changes property can be called to retrieve
+ * the constructed changes.
+ */
+class DiffChangeHelper {
+    /**
+     * Constructs a new DiffChangeHelper for the given DiffSequences.
+     */
+    constructor() {
+        this.m_changes = [];
+        this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;
+        this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;
+        this.m_originalCount = 0;
+        this.m_modifiedCount = 0;
+    }
+    /**
+     * Marks the beginning of the next change in the set of differences.
+     */
+    MarkNextChange() {
+        // Only add to the list if there is something to add
+        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
+            // Add the new change to our list
+            this.m_changes.push(new diffChange_1.DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));
+        }
+        // Reset for the next change
+        this.m_originalCount = 0;
+        this.m_modifiedCount = 0;
+        this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;
+        this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;
+    }
+    /**
+     * Adds the original element at the given position to the elements
+     * affected by the current change. The modified index gives context
+     * to the change position with respect to the original sequence.
+     * @param originalIndex The index of the original element to add.
+     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.
+     */
+    AddOriginalElement(originalIndex, modifiedIndex) {
+        // The 'true' start index is the smallest of the ones we've seen
+        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);
+        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);
+        this.m_originalCount++;
+    }
+    /**
+     * Adds the modified element at the given position to the elements
+     * affected by the current change. The original index gives context
+     * to the change position with respect to the modified sequence.
+     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.
+     * @param modifiedIndex The index of the modified element to add.
+     */
+    AddModifiedElement(originalIndex, modifiedIndex) {
+        // The 'true' start index is the smallest of the ones we've seen
+        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);
+        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);
+        this.m_modifiedCount++;
+    }
+    /**
+     * Retrieves all of the changes marked by the class.
+     */
+    getChanges() {
+        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
+            // Finish up on whatever is left
+            this.MarkNextChange();
+        }
+        return this.m_changes;
+    }
+    /**
+     * Retrieves all of the changes marked by the class in the reverse order
+     */
+    getReverseChanges() {
+        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
+            // Finish up on whatever is left
+            this.MarkNextChange();
+        }
+        this.m_changes.reverse();
+        return this.m_changes;
+    }
+}
+/**
+ * An implementation of the difference algorithm described in
+ * "An O(ND) Difference Algorithm and its variations" by Eugene W. Myers
+ */
+class LcsDiff {
+    /**
+     * Constructs the DiffFinder
+     */
+    constructor(originalSequence, modifiedSequence, continueProcessingPredicate = null) {
+        this.ContinueProcessingPredicate = continueProcessingPredicate;
+        this._originalSequence = originalSequence;
+        this._modifiedSequence = modifiedSequence;
+        const [originalStringElements, originalElementsOrHash, originalHasStrings] = LcsDiff._getElements(originalSequence);
+        const [modifiedStringElements, modifiedElementsOrHash, modifiedHasStrings] = LcsDiff._getElements(modifiedSequence);
+        this._hasStrings = (originalHasStrings && modifiedHasStrings);
+        this._originalStringElements = originalStringElements;
+        this._originalElementsOrHash = originalElementsOrHash;
+        this._modifiedStringElements = modifiedStringElements;
+        this._modifiedElementsOrHash = modifiedElementsOrHash;
+        this.m_forwardHistory = [];
+        this.m_reverseHistory = [];
+    }
+    static _isStringArray(arr) {
+        return (arr.length > 0 && typeof arr[0] === 'string');
+    }
+    static _getElements(sequence) {
+        const elements = sequence.getElements();
+        if (LcsDiff._isStringArray(elements)) {
+            const hashes = new Int32Array(elements.length);
+            for (let i = 0, len = elements.length; i < len; i++) {
+                hashes[i] = (0, hash_1.stringHash)(elements[i], 0);
+            }
+            return [elements, hashes, true];
+        }
+        if (elements instanceof Int32Array) {
+            return [[], elements, false];
+        }
+        return [[], new Int32Array(elements), false];
+    }
+    ElementsAreEqual(originalIndex, newIndex) {
+        if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) {
+            return false;
+        }
+        return (this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true);
+    }
+    ElementsAreStrictEqual(originalIndex, newIndex) {
+        if (!this.ElementsAreEqual(originalIndex, newIndex)) {
+            return false;
+        }
+        const originalElement = LcsDiff._getStrictElement(this._originalSequence, originalIndex);
+        const modifiedElement = LcsDiff._getStrictElement(this._modifiedSequence, newIndex);
+        return (originalElement === modifiedElement);
+    }
+    static _getStrictElement(sequence, index) {
+        if (typeof sequence.getStrictElement === 'function') {
+            return sequence.getStrictElement(index);
+        }
+        return null;
+    }
+    OriginalElementsAreEqual(index1, index2) {
+        if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) {
+            return false;
+        }
+        return (this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true);
+    }
+    ModifiedElementsAreEqual(index1, index2) {
+        if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) {
+            return false;
+        }
+        return (this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true);
+    }
+    ComputeDiff(pretty) {
+        return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty);
+    }
+    /**
+     * Computes the differences between the original and modified input
+     * sequences on the bounded range.
+     * @returns An array of the differences between the two input sequences.
+     */
+    _ComputeDiff(originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {
+        const quitEarlyArr = [false];
+        let changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);
+        if (pretty) {
+            // We have to clean up the computed diff to be more intuitive
+            // but it turns out this cannot be done correctly until the entire set
+            // of diffs have been computed
+            changes = this.PrettifyChanges(changes);
+        }
+        return {
+            quitEarly: quitEarlyArr[0],
+            changes: changes
+        };
+    }
+    /**
+     * Private helper method which computes the differences on the bounded range
+     * recursively.
+     * @returns An array of the differences between the two input sequences.
+     */
+    ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {
+        quitEarlyArr[0] = false;
+        // Find the start of the differences
+        while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {
+            originalStart++;
+            modifiedStart++;
+        }
+        // Find the end of the differences
+        while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {
+            originalEnd--;
+            modifiedEnd--;
+        }
+        // In the special case where we either have all insertions or all deletions or the sequences are identical
+        if (originalStart > originalEnd || modifiedStart > modifiedEnd) {
+            let changes;
+            if (modifiedStart <= modifiedEnd) {
+                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
+                // All insertions
+                changes = [
+                    new diffChange_1.DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)
+                ];
+            }
+            else if (originalStart <= originalEnd) {
+                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');
+                // All deletions
+                changes = [
+                    new diffChange_1.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)
+                ];
+            }
+            else {
+                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
+                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');
+                // Identical sequences - No differences
+                changes = [];
+            }
+            return changes;
+        }
+        // This problem can be solved using the Divide-And-Conquer technique.
+        const midOriginalArr = [0];
+        const midModifiedArr = [0];
+        const result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);
+        const midOriginal = midOriginalArr[0];
+        const midModified = midModifiedArr[0];
+        if (result !== null) {
+            // Result is not-null when there was enough memory to compute the changes while
+            // searching for the recursion point
+            return result;
+        }
+        else if (!quitEarlyArr[0]) {
+            // We can break the problem down recursively by finding the changes in the
+            // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)
+            // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)
+            // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point
+            const leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);
+            let rightChanges = [];
+            if (!quitEarlyArr[0]) {
+                rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);
+            }
+            else {
+                // We didn't have time to finish the first half, so we don't have time to compute this half.
+                // Consider the entire rest of the sequence different.
+                rightChanges = [
+                    new diffChange_1.DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)
+                ];
+            }
+            return this.ConcatenateChanges(leftChanges, rightChanges);
+        }
+        // If we hit here, we quit early, and so can't return anything meaningful
+        return [
+            new diffChange_1.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)
+        ];
+    }
+    WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {
+        let forwardChanges = null;
+        let reverseChanges = null;
+        // First, walk backward through the forward diagonals history
+        let changeHelper = new DiffChangeHelper();
+        let diagonalMin = diagonalForwardStart;
+        let diagonalMax = diagonalForwardEnd;
+        let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;
+        let lastOriginalIndex = -1073741824 /* Constants.MIN_SAFE_SMALL_INTEGER */;
+        let historyIndex = this.m_forwardHistory.length - 1;
+        do {
+            // Get the diagonal index from the relative diagonal number
+            const diagonal = diagonalRelative + diagonalForwardBase;
+            // Figure out where we came from
+            if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {
+                // Vertical line (the element is an insert)
+                originalIndex = forwardPoints[diagonal + 1];
+                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;
+                if (originalIndex < lastOriginalIndex) {
+                    changeHelper.MarkNextChange();
+                }
+                lastOriginalIndex = originalIndex;
+                changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);
+                diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration
+            }
+            else {
+                // Horizontal line (the element is a deletion)
+                originalIndex = forwardPoints[diagonal - 1] + 1;
+                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;
+                if (originalIndex < lastOriginalIndex) {
+                    changeHelper.MarkNextChange();
+                }
+                lastOriginalIndex = originalIndex - 1;
+                changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);
+                diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration
+            }
+            if (historyIndex >= 0) {
+                forwardPoints = this.m_forwardHistory[historyIndex];
+                diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot
+                diagonalMin = 1;
+                diagonalMax = forwardPoints.length - 1;
+            }
+        } while (--historyIndex >= -1);
+        // Ironically, we get the forward changes as the reverse of the
+        // order we added them since we technically added them backwards
+        forwardChanges = changeHelper.getReverseChanges();
+        if (quitEarlyArr[0]) {
+            // TODO: Calculate a partial from the reverse diagonals.
+            //       For now, just assume everything after the midOriginal/midModified point is a diff
+            let originalStartPoint = midOriginalArr[0] + 1;
+            let modifiedStartPoint = midModifiedArr[0] + 1;
+            if (forwardChanges !== null && forwardChanges.length > 0) {
+                const lastForwardChange = forwardChanges[forwardChanges.length - 1];
+                originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());
+                modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());
+            }
+            reverseChanges = [
+                new diffChange_1.DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)
+            ];
+        }
+        else {
+            // Now walk backward through the reverse diagonals history
+            changeHelper = new DiffChangeHelper();
+            diagonalMin = diagonalReverseStart;
+            diagonalMax = diagonalReverseEnd;
+            diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;
+            lastOriginalIndex = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;
+            historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;
+            do {
+                // Get the diagonal index from the relative diagonal number
+                const diagonal = diagonalRelative + diagonalReverseBase;
+                // Figure out where we came from
+                if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {
+                    // Horizontal line (the element is a deletion))
+                    originalIndex = reversePoints[diagonal + 1] - 1;
+                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;
+                    if (originalIndex > lastOriginalIndex) {
+                        changeHelper.MarkNextChange();
+                    }
+                    lastOriginalIndex = originalIndex + 1;
+                    changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);
+                    diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration
+                }
+                else {
+                    // Vertical line (the element is an insertion)
+                    originalIndex = reversePoints[diagonal - 1];
+                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;
+                    if (originalIndex > lastOriginalIndex) {
+                        changeHelper.MarkNextChange();
+                    }
+                    lastOriginalIndex = originalIndex;
+                    changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);
+                    diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration
+                }
+                if (historyIndex >= 0) {
+                    reversePoints = this.m_reverseHistory[historyIndex];
+                    diagonalReverseBase = reversePoints[0]; //We stored this in the first spot
+                    diagonalMin = 1;
+                    diagonalMax = reversePoints.length - 1;
+                }
+            } while (--historyIndex >= -1);
+            // There are cases where the reverse history will find diffs that
+            // are correct, but not intuitive, so we need shift them.
+            reverseChanges = changeHelper.getChanges();
+        }
+        return this.ConcatenateChanges(forwardChanges, reverseChanges);
+    }
+    /**
+     * Given the range to compute the diff on, this method finds the point:
+     * (midOriginal, midModified)
+     * that exists in the middle of the LCS of the two sequences and
+     * is the point at which the LCS problem may be broken down recursively.
+     * This method will try to keep the LCS trace in memory. If the LCS recursion
+     * point is calculated and the full trace is available in memory, then this method
+     * will return the change list.
+     * @param originalStart The start bound of the original sequence range
+     * @param originalEnd The end bound of the original sequence range
+     * @param modifiedStart The start bound of the modified sequence range
+     * @param modifiedEnd The end bound of the modified sequence range
+     * @param midOriginal The middle point of the original sequence range
+     * @param midModified The middle point of the modified sequence range
+     * @returns The diff changes, if available, otherwise null
+     */
+    ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {
+        let originalIndex = 0, modifiedIndex = 0;
+        let diagonalForwardStart = 0, diagonalForwardEnd = 0;
+        let diagonalReverseStart = 0, diagonalReverseEnd = 0;
+        // To traverse the edit graph and produce the proper LCS, our actual
+        // start position is just outside the given boundary
+        originalStart--;
+        modifiedStart--;
+        // We set these up to make the compiler happy, but they will
+        // be replaced before we return with the actual recursion point
+        midOriginalArr[0] = 0;
+        midModifiedArr[0] = 0;
+        // Clear out the history
+        this.m_forwardHistory = [];
+        this.m_reverseHistory = [];
+        // Each cell in the two arrays corresponds to a diagonal in the edit graph.
+        // The integer value in the cell represents the originalIndex of the furthest
+        // reaching point found so far that ends in that diagonal.
+        // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.
+        const maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);
+        const numDiagonals = maxDifferences + 1;
+        const forwardPoints = new Int32Array(numDiagonals);
+        const reversePoints = new Int32Array(numDiagonals);
+        // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)
+        // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)
+        const diagonalForwardBase = (modifiedEnd - modifiedStart);
+        const diagonalReverseBase = (originalEnd - originalStart);
+        // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
+        //    diagonal number (relative to diagonalForwardBase)
+        // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
+        //    diagonal number (relative to diagonalReverseBase)
+        const diagonalForwardOffset = (originalStart - modifiedStart);
+        const diagonalReverseOffset = (originalEnd - modifiedEnd);
+        // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers
+        //   relative to the start diagonal with diagonal numbers relative to the end diagonal.
+        // The Even/Oddn-ness of this delta is important for determining when we should check for overlap
+        const delta = diagonalReverseBase - diagonalForwardBase;
+        const deltaIsEven = (delta % 2 === 0);
+        // Here we set up the start and end points as the furthest points found so far
+        // in both the forward and reverse directions, respectively
+        forwardPoints[diagonalForwardBase] = originalStart;
+        reversePoints[diagonalReverseBase] = originalEnd;
+        // Remember if we quit early, and thus need to do a best-effort result instead of a real result.
+        quitEarlyArr[0] = false;
+        // A couple of points:
+        // --With this method, we iterate on the number of differences between the two sequences.
+        //   The more differences there actually are, the longer this will take.
+        // --Also, as the number of differences increases, we have to search on diagonals further
+        //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).
+        // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences
+        //   is even and odd diagonals only when numDifferences is odd.
+        for (let numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {
+            let furthestOriginalIndex = 0;
+            let furthestModifiedIndex = 0;
+            // Run the algorithm in the forward direction
+            diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
+            diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
+            for (let diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {
+                // STEP 1: We extend the furthest reaching point in the present diagonal
+                // by looking at the diagonals above and below and picking the one whose point
+                // is further away from the start point (originalStart, modifiedStart)
+                if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {
+                    originalIndex = forwardPoints[diagonal + 1];
+                }
+                else {
+                    originalIndex = forwardPoints[diagonal - 1] + 1;
+                }
+                modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;
+                // Save the current originalIndex so we can test for false overlap in step 3
+                const tempOriginalIndex = originalIndex;
+                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal
+                // so long as the elements are equal.
+                while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {
+                    originalIndex++;
+                    modifiedIndex++;
+                }
+                forwardPoints[diagonal] = originalIndex;
+                if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {
+                    furthestOriginalIndex = originalIndex;
+                    furthestModifiedIndex = modifiedIndex;
+                }
+                // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)
+                // and diagonal is in the range of reverse diagonals computed for numDifferences-1
+                // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)
+                // then check for overlap.
+                if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {
+                    if (originalIndex >= reversePoints[diagonal]) {
+                        midOriginalArr[0] = originalIndex;
+                        midModifiedArr[0] = modifiedIndex;
+                        if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {
+                            // BINGO! We overlapped, and we have the full trace in memory!
+                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
+                        }
+                        else {
+                            // Either false overlap, or we didn't have enough memory for the full trace
+                            // Just return the recursion point
+                            return null;
+                        }
+                    }
+                }
+            }
+            // Check to see if we should be quitting early, before moving on to the next iteration.
+            const matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;
+            if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) {
+                // We can't finish, so skip ahead to generating a result from what we have.
+                quitEarlyArr[0] = true;
+                // Use the furthest distance we got in the forward direction.
+                midOriginalArr[0] = furthestOriginalIndex;
+                midModifiedArr[0] = furthestModifiedIndex;
+                if (matchLengthOfLongest > 0 && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {
+                    // Enough of the history is in memory to walk it backwards
+                    return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
+                }
+                else {
+                    // We didn't actually remember enough of the history.
+                    //Since we are quitting the diff early, we need to shift back the originalStart and modified start
+                    //back into the boundary limits since we decremented their value above beyond the boundary limit.
+                    originalStart++;
+                    modifiedStart++;
+                    return [
+                        new diffChange_1.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)
+                    ];
+                }
+            }
+            // Run the algorithm in the reverse direction
+            diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);
+            diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);
+            for (let diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {
+                // STEP 1: We extend the furthest reaching point in the present diagonal
+                // by looking at the diagonals above and below and picking the one whose point
+                // is further away from the start point (originalEnd, modifiedEnd)
+                if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {
+                    originalIndex = reversePoints[diagonal + 1] - 1;
+                }
+                else {
+                    originalIndex = reversePoints[diagonal - 1];
+                }
+                modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;
+                // Save the current originalIndex so we can test for false overlap
+                const tempOriginalIndex = originalIndex;
+                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal
+                // as long as the elements are equal.
+                while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {
+                    originalIndex--;
+                    modifiedIndex--;
+                }
+                reversePoints[diagonal] = originalIndex;
+                // STEP 4: If delta is even (overlap first happens on reverse when delta is even)
+                // and diagonal is in the range of forward diagonals computed for numDifferences
+                // then check for overlap.
+                if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {
+                    if (originalIndex <= forwardPoints[diagonal]) {
+                        midOriginalArr[0] = originalIndex;
+                        midModifiedArr[0] = modifiedIndex;
+                        if (tempOriginalIndex >= forwardPoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {
+                            // BINGO! We overlapped, and we have the full trace in memory!
+                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
+                        }
+                        else {
+                            // Either false overlap, or we didn't have enough memory for the full trace
+                            // Just return the recursion point
+                            return null;
+                        }
+                    }
+                }
+            }
+            // Save current vectors to history before the next iteration
+            if (numDifferences <= 1447 /* LocalConstants.MaxDifferencesHistory */) {
+                // We are allocating space for one extra int, which we fill with
+                // the index of the diagonal base index
+                let temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2);
+                temp[0] = diagonalForwardBase - diagonalForwardStart + 1;
+                MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);
+                this.m_forwardHistory.push(temp);
+                temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2);
+                temp[0] = diagonalReverseBase - diagonalReverseStart + 1;
+                MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);
+                this.m_reverseHistory.push(temp);
+            }
+        }
+        // If we got here, then we have the full trace in history. We just have to convert it to a change list
+        // NOTE: This part is a bit messy
+        return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
+    }
+    /**
+     * Shifts the given changes to provide a more intuitive diff.
+     * While the first element in a diff matches the first element after the diff,
+     * we shift the diff down.
+     *
+     * @param changes The list of changes to shift
+     * @returns The shifted changes
+     */
+    PrettifyChanges(changes) {
+        // Shift all the changes down first
+        for (let i = 0; i < changes.length; i++) {
+            const change = changes[i];
+            const originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this._originalElementsOrHash.length;
+            const modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length;
+            const checkOriginal = change.originalLength > 0;
+            const checkModified = change.modifiedLength > 0;
+            while (change.originalStart + change.originalLength < originalStop
+                && change.modifiedStart + change.modifiedLength < modifiedStop
+                && (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength))
+                && (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {
+                const startStrictEqual = this.ElementsAreStrictEqual(change.originalStart, change.modifiedStart);
+                const endStrictEqual = this.ElementsAreStrictEqual(change.originalStart + change.originalLength, change.modifiedStart + change.modifiedLength);
+                if (endStrictEqual && !startStrictEqual) {
+                    // moving the change down would create an equal change, but the elements are not strict equal
+                    break;
+                }
+                change.originalStart++;
+                change.modifiedStart++;
+            }
+            const mergedChangeArr = [null];
+            if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {
+                changes[i] = mergedChangeArr[0];
+                changes.splice(i + 1, 1);
+                i--;
+                continue;
+            }
+        }
+        // Shift changes back up until we hit empty or whitespace-only lines
+        for (let i = changes.length - 1; i >= 0; i--) {
+            const change = changes[i];
+            let originalStop = 0;
+            let modifiedStop = 0;
+            if (i > 0) {
+                const prevChange = changes[i - 1];
+                originalStop = prevChange.originalStart + prevChange.originalLength;
+                modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;
+            }
+            const checkOriginal = change.originalLength > 0;
+            const checkModified = change.modifiedLength > 0;
+            let bestDelta = 0;
+            let bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);
+            for (let delta = 1;; delta++) {
+                const originalStart = change.originalStart - delta;
+                const modifiedStart = change.modifiedStart - delta;
+                if (originalStart < originalStop || modifiedStart < modifiedStop) {
+                    break;
+                }
+                if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {
+                    break;
+                }
+                if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {
+                    break;
+                }
+                const touchingPreviousChange = (originalStart === originalStop && modifiedStart === modifiedStop);
+                const score = ((touchingPreviousChange ? 5 : 0)
+                    + this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength));
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestDelta = delta;
+                }
+            }
+            change.originalStart -= bestDelta;
+            change.modifiedStart -= bestDelta;
+            const mergedChangeArr = [null];
+            if (i > 0 && this.ChangesOverlap(changes[i - 1], changes[i], mergedChangeArr)) {
+                changes[i - 1] = mergedChangeArr[0];
+                changes.splice(i, 1);
+                i++;
+                continue;
+            }
+        }
+        // There could be multiple longest common substrings.
+        // Give preference to the ones containing longer lines
+        if (this._hasStrings) {
+            for (let i = 1, len = changes.length; i < len; i++) {
+                const aChange = changes[i - 1];
+                const bChange = changes[i];
+                const matchedLength = bChange.originalStart - aChange.originalStart - aChange.originalLength;
+                const aOriginalStart = aChange.originalStart;
+                const bOriginalEnd = bChange.originalStart + bChange.originalLength;
+                const abOriginalLength = bOriginalEnd - aOriginalStart;
+                const aModifiedStart = aChange.modifiedStart;
+                const bModifiedEnd = bChange.modifiedStart + bChange.modifiedLength;
+                const abModifiedLength = bModifiedEnd - aModifiedStart;
+                // Avoid wasting a lot of time with these searches
+                if (matchedLength < 5 && abOriginalLength < 20 && abModifiedLength < 20) {
+                    const t = this._findBetterContiguousSequence(aOriginalStart, abOriginalLength, aModifiedStart, abModifiedLength, matchedLength);
+                    if (t) {
+                        const [originalMatchStart, modifiedMatchStart] = t;
+                        if (originalMatchStart !== aChange.originalStart + aChange.originalLength || modifiedMatchStart !== aChange.modifiedStart + aChange.modifiedLength) {
+                            // switch to another sequence that has a better score
+                            aChange.originalLength = originalMatchStart - aChange.originalStart;
+                            aChange.modifiedLength = modifiedMatchStart - aChange.modifiedStart;
+                            bChange.originalStart = originalMatchStart + matchedLength;
+                            bChange.modifiedStart = modifiedMatchStart + matchedLength;
+                            bChange.originalLength = bOriginalEnd - bChange.originalStart;
+                            bChange.modifiedLength = bModifiedEnd - bChange.modifiedStart;
+                        }
+                    }
+                }
+            }
+        }
+        return changes;
+    }
+    _findBetterContiguousSequence(originalStart, originalLength, modifiedStart, modifiedLength, desiredLength) {
+        if (originalLength < desiredLength || modifiedLength < desiredLength) {
+            return null;
+        }
+        const originalMax = originalStart + originalLength - desiredLength + 1;
+        const modifiedMax = modifiedStart + modifiedLength - desiredLength + 1;
+        let bestScore = 0;
+        let bestOriginalStart = 0;
+        let bestModifiedStart = 0;
+        for (let i = originalStart; i < originalMax; i++) {
+            for (let j = modifiedStart; j < modifiedMax; j++) {
+                const score = this._contiguousSequenceScore(i, j, desiredLength);
+                if (score > 0 && score > bestScore) {
+                    bestScore = score;
+                    bestOriginalStart = i;
+                    bestModifiedStart = j;
+                }
+            }
+        }
+        if (bestScore > 0) {
+            return [bestOriginalStart, bestModifiedStart];
+        }
+        return null;
+    }
+    _contiguousSequenceScore(originalStart, modifiedStart, length) {
+        let score = 0;
+        for (let l = 0; l < length; l++) {
+            if (!this.ElementsAreEqual(originalStart + l, modifiedStart + l)) {
+                return 0;
+            }
+            score += this._originalStringElements[originalStart + l].length;
+        }
+        return score;
+    }
+    _OriginalIsBoundary(index) {
+        if (index <= 0 || index >= this._originalElementsOrHash.length - 1) {
+            return true;
+        }
+        return (this._hasStrings && /^\s*$/.test(this._originalStringElements[index]));
+    }
+    _OriginalRegionIsBoundary(originalStart, originalLength) {
+        if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {
+            return true;
+        }
+        if (originalLength > 0) {
+            const originalEnd = originalStart + originalLength;
+            if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _ModifiedIsBoundary(index) {
+        if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) {
+            return true;
+        }
+        return (this._hasStrings && /^\s*$/.test(this._modifiedStringElements[index]));
+    }
+    _ModifiedRegionIsBoundary(modifiedStart, modifiedLength) {
+        if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {
+            return true;
+        }
+        if (modifiedLength > 0) {
+            const modifiedEnd = modifiedStart + modifiedLength;
+            if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _boundaryScore(originalStart, originalLength, modifiedStart, modifiedLength) {
+        const originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);
+        const modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);
+        return (originalScore + modifiedScore);
+    }
+    /**
+     * Concatenates the two input DiffChange lists and returns the resulting
+     * list.
+     * @param The left changes
+     * @param The right changes
+     * @returns The concatenated list
+     */
+    ConcatenateChanges(left, right) {
+        const mergedChangeArr = [];
+        if (left.length === 0 || right.length === 0) {
+            return (right.length > 0) ? right : left;
+        }
+        else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {
+            // Since we break the problem down recursively, it is possible that we
+            // might recurse in the middle of a change thereby splitting it into
+            // two changes. Here in the combining stage, we detect and fuse those
+            // changes back together
+            const result = new Array(left.length + right.length - 1);
+            MyArray.Copy(left, 0, result, 0, left.length - 1);
+            result[left.length - 1] = mergedChangeArr[0];
+            MyArray.Copy(right, 1, result, left.length, right.length - 1);
+            return result;
+        }
+        else {
+            const result = new Array(left.length + right.length);
+            MyArray.Copy(left, 0, result, 0, left.length);
+            MyArray.Copy(right, 0, result, left.length, right.length);
+            return result;
+        }
+    }
+    /**
+     * Returns true if the two changes overlap and can be merged into a single
+     * change
+     * @param left The left change
+     * @param right The right change
+     * @param mergedChange The merged change if the two overlap, null otherwise
+     * @returns True if the two changes overlap
+     */
+    ChangesOverlap(left, right, mergedChangeArr) {
+        Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');
+        Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');
+        if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {
+            const originalStart = left.originalStart;
+            let originalLength = left.originalLength;
+            const modifiedStart = left.modifiedStart;
+            let modifiedLength = left.modifiedLength;
+            if (left.originalStart + left.originalLength >= right.originalStart) {
+                originalLength = right.originalStart + right.originalLength - left.originalStart;
+            }
+            if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {
+                modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;
+            }
+            mergedChangeArr[0] = new diffChange_1.DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);
+            return true;
+        }
+        else {
+            mergedChangeArr[0] = null;
+            return false;
+        }
+    }
+    /**
+     * Helper method used to clip a diagonal index to the range of valid
+     * diagonals. This also decides whether or not the diagonal index,
+     * if it exceeds the boundary, should be clipped to the boundary or clipped
+     * one inside the boundary depending on the Even/Odd status of the boundary
+     * and numDifferences.
+     * @param diagonal The index of the diagonal to clip.
+     * @param numDifferences The current number of differences being iterated upon.
+     * @param diagonalBaseIndex The base reference diagonal.
+     * @param numDiagonals The total number of diagonals.
+     * @returns The clipped diagonal index.
+     */
+    ClipDiagonalBound(diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {
+        if (diagonal >= 0 && diagonal < numDiagonals) {
+            // Nothing to clip, its in range
+            return diagonal;
+        }
+        // diagonalsBelow: The number of diagonals below the reference diagonal
+        // diagonalsAbove: The number of diagonals above the reference diagonal
+        const diagonalsBelow = diagonalBaseIndex;
+        const diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;
+        const diffEven = (numDifferences % 2 === 0);
+        if (diagonal < 0) {
+            const lowerBoundEven = (diagonalsBelow % 2 === 0);
+            return (diffEven === lowerBoundEven) ? 0 : 1;
+        }
+        else {
+            const upperBoundEven = (diagonalsAbove % 2 === 0);
+            return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;
+        }
+    }
+}
+exports.LcsDiff = LcsDiff;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/diff/diffChange.js":
+/*!*************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/diff/diffChange.js ***!
+  \*************************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DiffChange = void 0;
+/**
+ * Represents information about a specific difference between two sequences.
+ */
+class DiffChange {
+    /**
+     * Constructs a new DiffChange with the given sequence information
+     * and content.
+     */
+    constructor(originalStart, originalLength, modifiedStart, modifiedLength) {
+        //Debug.Assert(originalLength > 0 || modifiedLength > 0, "originalLength and modifiedLength cannot both be <= 0");
+        this.originalStart = originalStart;
+        this.originalLength = originalLength;
+        this.modifiedStart = modifiedStart;
+        this.modifiedLength = modifiedLength;
+    }
+    /**
+     * The end point (exclusive) of the change in the original sequence.
+     */
+    getOriginalEnd() {
+        return this.originalStart + this.originalLength;
+    }
+    /**
+     * The end point (exclusive) of the change in the modified sequence.
+     */
+    getModifiedEnd() {
+        return this.modifiedStart + this.modifiedLength;
+    }
+}
+exports.DiffChange = DiffChange;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/errors.js":
+/*!****************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/errors.js ***!
+  \****************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.BugIndicatingError = exports.ErrorNoTelemetry = exports.CancellationError = exports.isCancellationError = exports.onUnexpectedError = exports.errorHandler = exports.ErrorHandler = void 0;
+// Avoid circular dependency on EventEmitter by implementing a subset of the interface.
+class ErrorHandler {
+    constructor() {
+        this.listeners = [];
+        this.unexpectedErrorHandler = function (e) {
+            setTimeout(() => {
+                if (e.stack) {
+                    if (ErrorNoTelemetry.isErrorNoTelemetry(e)) {
+                        throw new ErrorNoTelemetry(e.message + '\n\n' + e.stack);
+                    }
+                    throw new Error(e.message + '\n\n' + e.stack);
+                }
+                throw e;
+            }, 0);
+        };
+    }
+    addListener(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this._removeListener(listener);
+        };
+    }
+    emit(e) {
+        this.listeners.forEach((listener) => {
+            listener(e);
+        });
+    }
+    _removeListener(listener) {
+        this.listeners.splice(this.listeners.indexOf(listener), 1);
+    }
+    setUnexpectedErrorHandler(newUnexpectedErrorHandler) {
+        this.unexpectedErrorHandler = newUnexpectedErrorHandler;
+    }
+    getUnexpectedErrorHandler() {
+        return this.unexpectedErrorHandler;
+    }
+    onUnexpectedError(e) {
+        this.unexpectedErrorHandler(e);
+        this.emit(e);
+    }
+    // For external errors, we don't want the listeners to be called
+    onUnexpectedExternalError(e) {
+        this.unexpectedErrorHandler(e);
+    }
+}
+exports.ErrorHandler = ErrorHandler;
+exports.errorHandler = new ErrorHandler();
+function onUnexpectedError(e) {
+    // ignore errors from cancelled promises
+    if (!isCancellationError(e)) {
+        exports.errorHandler.onUnexpectedError(e);
+    }
+    return undefined;
+}
+exports.onUnexpectedError = onUnexpectedError;
+const canceledName = 'Canceled';
+/**
+ * Checks if the given error is a promise in canceled state
+ */
+function isCancellationError(error) {
+    if (error instanceof CancellationError) {
+        return true;
+    }
+    return error instanceof Error && error.name === canceledName && error.message === canceledName;
+}
+exports.isCancellationError = isCancellationError;
+// !!!IMPORTANT!!!
+// Do NOT change this class because it is also used as an API-type.
+class CancellationError extends Error {
+    constructor() {
+        super(canceledName);
+        this.name = this.message;
+    }
+}
+exports.CancellationError = CancellationError;
+/**
+ * Error that when thrown won't be logged in telemetry as an unhandled error.
+ */
+class ErrorNoTelemetry extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = 'CodeExpectedError';
+    }
+    static fromError(err) {
+        if (err instanceof ErrorNoTelemetry) {
+            return err;
+        }
+        const result = new ErrorNoTelemetry();
+        result.message = err.message;
+        result.stack = err.stack;
+        return result;
+    }
+    static isErrorNoTelemetry(err) {
+        return err.name === 'CodeExpectedError';
+    }
+}
+exports.ErrorNoTelemetry = ErrorNoTelemetry;
+/**
+ * This error indicates a bug.
+ * Do not throw this for invalid user input.
+ * Only catch this error to recover gracefully from bugs.
+ */
+class BugIndicatingError extends Error {
+    constructor(message) {
+        super(message || 'An unexpected bug occurred.');
+        Object.setPrototypeOf(this, BugIndicatingError.prototype);
+        // Because we know for sure only buggy code throws this,
+        // we definitely want to break here and fix the bug.
+        // eslint-disable-next-line no-debugger
+        // debugger;
+    }
+}
+exports.BugIndicatingError = BugIndicatingError;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/hash.js":
+/*!**************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/hash.js ***!
+  \**************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.StringSHA1 = exports.toHexString = exports.stringHash = exports.numberHash = exports.doHash = void 0;
+const strings = __webpack_require__(/*! ./strings */ "./node_modules/vscode-diff/dist/vs/base/common/strings.js");
+function doHash(obj, hashVal) {
+    switch (typeof obj) {
+        case 'object':
+            if (obj === null) {
+                return numberHash(349, hashVal);
+            }
+            else if (Array.isArray(obj)) {
+                return arrayHash(obj, hashVal);
+            }
+            return objectHash(obj, hashVal);
+        case 'string':
+            return stringHash(obj, hashVal);
+        case 'boolean':
+            return booleanHash(obj, hashVal);
+        case 'number':
+            return numberHash(obj, hashVal);
+        case 'undefined':
+            return numberHash(937, hashVal);
+        default:
+            return numberHash(617, hashVal);
+    }
+}
+exports.doHash = doHash;
+function numberHash(val, initialHashVal) {
+    return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32
+}
+exports.numberHash = numberHash;
+function booleanHash(b, initialHashVal) {
+    return numberHash(b ? 433 : 863, initialHashVal);
+}
+function stringHash(s, hashVal) {
+    hashVal = numberHash(149417, hashVal);
+    for (let i = 0, length = s.length; i < length; i++) {
+        hashVal = numberHash(s.charCodeAt(i), hashVal);
+    }
+    return hashVal;
+}
+exports.stringHash = stringHash;
+function arrayHash(arr, initialHashVal) {
+    initialHashVal = numberHash(104579, initialHashVal);
+    return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);
+}
+function objectHash(obj, initialHashVal) {
+    initialHashVal = numberHash(181387, initialHashVal);
+    return Object.keys(obj).sort().reduce((hashVal, key) => {
+        hashVal = stringHash(key, hashVal);
+        return doHash(obj[key], hashVal);
+    }, initialHashVal);
+}
+function leftRotate(value, bits, totalBits = 32) {
+    // delta + bits = totalBits
+    const delta = totalBits - bits;
+    // All ones, expect `delta` zeros aligned to the right
+    const mask = ~((1 << delta) - 1);
+    // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)
+    return ((value << bits) | ((mask & value) >>> delta)) >>> 0;
+}
+function fill(dest, index = 0, count = dest.byteLength, value = 0) {
+    for (let i = 0; i < count; i++) {
+        dest[index + i] = value;
+    }
+}
+function leftPad(value, length, char = '0') {
+    while (value.length < length) {
+        value = char + value;
+    }
+    return value;
+}
+function toHexString(bufferOrValue, bitsize = 32) {
+    if (bufferOrValue instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);
+}
+exports.toHexString = toHexString;
+/**
+ * A SHA1 implementation that works with strings and does not allocate.
+ */
+class StringSHA1 {
+    constructor() {
+        this._h0 = 0x67452301;
+        this._h1 = 0xEFCDAB89;
+        this._h2 = 0x98BADCFE;
+        this._h3 = 0x10325476;
+        this._h4 = 0xC3D2E1F0;
+        this._buff = new Uint8Array(64 /* SHA1Constant.BLOCK_SIZE */ + 3 /* to fit any utf-8 */);
+        this._buffDV = new DataView(this._buff.buffer);
+        this._buffLen = 0;
+        this._totalLen = 0;
+        this._leftoverHighSurrogate = 0;
+        this._finished = false;
+    }
+    update(str) {
+        const strLen = str.length;
+        if (strLen === 0) {
+            return;
+        }
+        const buff = this._buff;
+        let buffLen = this._buffLen;
+        let leftoverHighSurrogate = this._leftoverHighSurrogate;
+        let charCode;
+        let offset;
+        if (leftoverHighSurrogate !== 0) {
+            charCode = leftoverHighSurrogate;
+            offset = -1;
+            leftoverHighSurrogate = 0;
+        }
+        else {
+            charCode = str.charCodeAt(0);
+            offset = 0;
+        }
+        while (true) {
+            let codePoint = charCode;
+            if (strings.isHighSurrogate(charCode)) {
+                if (offset + 1 < strLen) {
+                    const nextCharCode = str.charCodeAt(offset + 1);
+                    if (strings.isLowSurrogate(nextCharCode)) {
+                        offset++;
+                        codePoint = strings.computeCodePoint(charCode, nextCharCode);
+                    }
+                    else {
+                        // illegal => unicode replacement character
+                        codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;
+                    }
+                }
+                else {
+                    // last character is a surrogate pair
+                    leftoverHighSurrogate = charCode;
+                    break;
+                }
+            }
+            else if (strings.isLowSurrogate(charCode)) {
+                // illegal => unicode replacement character
+                codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;
+            }
+            buffLen = this._push(buff, buffLen, codePoint);
+            offset++;
+            if (offset < strLen) {
+                charCode = str.charCodeAt(offset);
+            }
+            else {
+                break;
+            }
+        }
+        this._buffLen = buffLen;
+        this._leftoverHighSurrogate = leftoverHighSurrogate;
+    }
+    _push(buff, buffLen, codePoint) {
+        if (codePoint < 0x0080) {
+            buff[buffLen++] = codePoint;
+        }
+        else if (codePoint < 0x0800) {
+            buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+        }
+        else if (codePoint < 0x10000) {
+            buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+        }
+        else {
+            buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+        }
+        if (buffLen >= 64 /* SHA1Constant.BLOCK_SIZE */) {
+            this._step();
+            buffLen -= 64 /* SHA1Constant.BLOCK_SIZE */;
+            this._totalLen += 64 /* SHA1Constant.BLOCK_SIZE */;
+            // take last 3 in case of UTF8 overflow
+            buff[0] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 0];
+            buff[1] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 1];
+            buff[2] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 2];
+        }
+        return buffLen;
+    }
+    digest() {
+        if (!this._finished) {
+            this._finished = true;
+            if (this._leftoverHighSurrogate) {
+                // illegal => unicode replacement character
+                this._leftoverHighSurrogate = 0;
+                this._buffLen = this._push(this._buff, this._buffLen, 65533 /* SHA1Constant.UNICODE_REPLACEMENT */);
+            }
+            this._totalLen += this._buffLen;
+            this._wrapUp();
+        }
+        return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);
+    }
+    _wrapUp() {
+        this._buff[this._buffLen++] = 0x80;
+        fill(this._buff, this._buffLen);
+        if (this._buffLen > 56) {
+            this._step();
+            fill(this._buff);
+        }
+        // this will fit because the mantissa can cover up to 52 bits
+        const ml = 8 * this._totalLen;
+        this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);
+        this._buffDV.setUint32(60, ml % 4294967296, false);
+        this._step();
+    }
+    _step() {
+        const bigBlock32 = StringSHA1._bigBlock32;
+        const data = this._buffDV;
+        for (let j = 0; j < 64 /* 16*4 */; j += 4) {
+            bigBlock32.setUint32(j, data.getUint32(j, false), false);
+        }
+        for (let j = 64; j < 320 /* 80*4 */; j += 4) {
+            bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);
+        }
+        let a = this._h0;
+        let b = this._h1;
+        let c = this._h2;
+        let d = this._h3;
+        let e = this._h4;
+        let f, k;
+        let temp;
+        for (let j = 0; j < 80; j++) {
+            if (j < 20) {
+                f = (b & c) | ((~b) & d);
+                k = 0x5A827999;
+            }
+            else if (j < 40) {
+                f = b ^ c ^ d;
+                k = 0x6ED9EBA1;
+            }
+            else if (j < 60) {
+                f = (b & c) | (b & d) | (c & d);
+                k = 0x8F1BBCDC;
+            }
+            else {
+                f = b ^ c ^ d;
+                k = 0xCA62C1D6;
+            }
+            temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;
+            e = d;
+            d = c;
+            c = leftRotate(b, 30);
+            b = a;
+            a = temp;
+        }
+        this._h0 = (this._h0 + a) & 0xffffffff;
+        this._h1 = (this._h1 + b) & 0xffffffff;
+        this._h2 = (this._h2 + c) & 0xffffffff;
+        this._h3 = (this._h3 + d) & 0xffffffff;
+        this._h4 = (this._h4 + e) & 0xffffffff;
+    }
+}
+exports.StringSHA1 = StringSHA1;
+StringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/base/common/strings.js":
+/*!*****************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/base/common/strings.js ***!
+  \*****************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.computeCodePoint = exports.isLowSurrogate = exports.isHighSurrogate = exports.lastNonWhitespaceIndex = exports.firstNonWhitespaceIndex = void 0;
+/**
+ * Returns first index of the string that is not whitespace.
+ * If string is empty or contains only whitespaces, returns -1
+ */
+function firstNonWhitespaceIndex(str) {
+    for (let i = 0, len = str.length; i < len; i++) {
+        const chCode = str.charCodeAt(i);
+        if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.firstNonWhitespaceIndex = firstNonWhitespaceIndex;
+/**
+ * Returns last index of the string that is not whitespace.
+ * If string is empty or contains only whitespaces, returns -1
+ */
+function lastNonWhitespaceIndex(str, startIndex = str.length - 1) {
+    for (let i = startIndex; i >= 0; i--) {
+        const chCode = str.charCodeAt(i);
+        if (chCode !== 32 /* CharCode.Space */ && chCode !== 9 /* CharCode.Tab */) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.lastNonWhitespaceIndex = lastNonWhitespaceIndex;
+/**
+ * See http://en.wikipedia.org/wiki/Surrogate_pair
+ */
+function isHighSurrogate(charCode) {
+    return (0xD800 <= charCode && charCode <= 0xDBFF);
+}
+exports.isHighSurrogate = isHighSurrogate;
+/**
+ * See http://en.wikipedia.org/wiki/Surrogate_pair
+ */
+function isLowSurrogate(charCode) {
+    return (0xDC00 <= charCode && charCode <= 0xDFFF);
+}
+exports.isLowSurrogate = isLowSurrogate;
+/**
+ * See http://en.wikipedia.org/wiki/Surrogate_pair
+ */
+function computeCodePoint(highSurrogate, lowSurrogate) {
+    return ((highSurrogate - 0xD800) << 10) + (lowSurrogate - 0xDC00) + 0x10000;
+}
+exports.computeCodePoint = computeCodePoint;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/core/lineRange.js":
+/*!**************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/core/lineRange.js ***!
+  \**************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.LineRange = void 0;
+const errors_1 = __webpack_require__(/*! ../../../base/common/errors */ "./node_modules/vscode-diff/dist/vs/base/common/errors.js");
+const offsetRange_1 = __webpack_require__(/*! ./offsetRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js");
+const range_1 = __webpack_require__(/*! ./range */ "./node_modules/vscode-diff/dist/vs/editor/common/core/range.js");
+/**
+ * A range of lines (1-based).
+ */
+class LineRange {
+    static fromRange(range) {
+        return new LineRange(range.startLineNumber, range.endLineNumber);
+    }
+    static subtract(a, b) {
+        if (!b) {
+            return [a];
+        }
+        if (a.startLineNumber < b.startLineNumber && b.endLineNumberExclusive < a.endLineNumberExclusive) {
+            return [
+                new LineRange(a.startLineNumber, b.startLineNumber),
+                new LineRange(b.endLineNumberExclusive, a.endLineNumberExclusive)
+            ];
+        }
+        else if (b.startLineNumber <= a.startLineNumber && a.endLineNumberExclusive <= b.endLineNumberExclusive) {
+            return [];
+        }
+        else if (b.endLineNumberExclusive < a.endLineNumberExclusive) {
+            return [new LineRange(Math.max(b.endLineNumberExclusive, a.startLineNumber), a.endLineNumberExclusive)];
+        }
+        else {
+            return [new LineRange(a.startLineNumber, Math.min(b.startLineNumber, a.endLineNumberExclusive))];
+        }
+    }
+    /**
+     * @param lineRanges An array of sorted line ranges.
+     */
+    static joinMany(lineRanges) {
+        if (lineRanges.length === 0) {
+            return [];
+        }
+        let result = lineRanges[0];
+        for (let i = 1; i < lineRanges.length; i++) {
+            result = this.join(result, lineRanges[i]);
+        }
+        return result;
+    }
+    /**
+     * @param lineRanges1 Must be sorted.
+     * @param lineRanges2 Must be sorted.
+     */
+    static join(lineRanges1, lineRanges2) {
+        if (lineRanges1.length === 0) {
+            return lineRanges2;
+        }
+        if (lineRanges2.length === 0) {
+            return lineRanges1;
+        }
+        const result = [];
+        let i1 = 0;
+        let i2 = 0;
+        let current = null;
+        while (i1 < lineRanges1.length || i2 < lineRanges2.length) {
+            let next = null;
+            if (i1 < lineRanges1.length && i2 < lineRanges2.length) {
+                const lineRange1 = lineRanges1[i1];
+                const lineRange2 = lineRanges2[i2];
+                if (lineRange1.startLineNumber < lineRange2.startLineNumber) {
+                    next = lineRange1;
+                    i1++;
+                }
+                else {
+                    next = lineRange2;
+                    i2++;
+                }
+            }
+            else if (i1 < lineRanges1.length) {
+                next = lineRanges1[i1];
+                i1++;
+            }
+            else {
+                next = lineRanges2[i2];
+                i2++;
+            }
+            if (current === null) {
+                current = next;
+            }
+            else {
+                if (current.endLineNumberExclusive >= next.startLineNumber) {
+                    // merge
+                    current = new LineRange(current.startLineNumber, Math.max(current.endLineNumberExclusive, next.endLineNumberExclusive));
+                }
+                else {
+                    // push
+                    result.push(current);
+                    current = next;
+                }
+            }
+        }
+        if (current !== null) {
+            result.push(current);
+        }
+        return result;
+    }
+    static ofLength(startLineNumber, length) {
+        return new LineRange(startLineNumber, startLineNumber + length);
+    }
+    /**
+     * @internal
+     */
+    static deserialize(lineRange) {
+        return new LineRange(lineRange[0], lineRange[1]);
+    }
+    constructor(startLineNumber, endLineNumberExclusive) {
+        if (startLineNumber > endLineNumberExclusive) {
+            throw new errors_1.BugIndicatingError(`startLineNumber ${startLineNumber} cannot be after endLineNumberExclusive ${endLineNumberExclusive}`);
+        }
+        this.startLineNumber = startLineNumber;
+        this.endLineNumberExclusive = endLineNumberExclusive;
+    }
+    /**
+     * Indicates if this line range contains the given line number.
+     */
+    contains(lineNumber) {
+        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
+    }
+    /**
+     * Indicates if this line range is empty.
+     */
+    get isEmpty() {
+        return this.startLineNumber === this.endLineNumberExclusive;
+    }
+    /**
+     * Moves this line range by the given offset of line numbers.
+     */
+    delta(offset) {
+        return new LineRange(this.startLineNumber + offset, this.endLineNumberExclusive + offset);
+    }
+    deltaLength(offset) {
+        return new LineRange(this.startLineNumber, this.endLineNumberExclusive + offset);
+    }
+    /**
+     * The number of lines this line range spans.
+     */
+    get length() {
+        return this.endLineNumberExclusive - this.startLineNumber;
+    }
+    /**
+     * Creates a line range that combines this and the given line range.
+     */
+    join(other) {
+        return new LineRange(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));
+    }
+    toString() {
+        return `[${this.startLineNumber},${this.endLineNumberExclusive})`;
+    }
+    /**
+     * The resulting range is empty if the ranges do not intersect, but touch.
+     * If the ranges don't even touch, the result is undefined.
+     */
+    intersect(other) {
+        const startLineNumber = Math.max(this.startLineNumber, other.startLineNumber);
+        const endLineNumberExclusive = Math.min(this.endLineNumberExclusive, other.endLineNumberExclusive);
+        if (startLineNumber <= endLineNumberExclusive) {
+            return new LineRange(startLineNumber, endLineNumberExclusive);
+        }
+        return undefined;
+    }
+    intersectsStrict(other) {
+        return this.startLineNumber < other.endLineNumberExclusive && other.startLineNumber < this.endLineNumberExclusive;
+    }
+    overlapOrTouch(other) {
+        return this.startLineNumber <= other.endLineNumberExclusive && other.startLineNumber <= this.endLineNumberExclusive;
+    }
+    equals(b) {
+        return this.startLineNumber === b.startLineNumber && this.endLineNumberExclusive === b.endLineNumberExclusive;
+    }
+    toInclusiveRange() {
+        if (this.isEmpty) {
+            return null;
+        }
+        return new range_1.Range(this.startLineNumber, 1, this.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER);
+    }
+    toExclusiveRange() {
+        return new range_1.Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1);
+    }
+    mapToLineArray(f) {
+        const result = [];
+        for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {
+            result.push(f(lineNumber));
+        }
+        return result;
+    }
+    forEach(f) {
+        for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {
+            f(lineNumber);
+        }
+    }
+    /**
+     * @internal
+     */
+    serialize() {
+        return [this.startLineNumber, this.endLineNumberExclusive];
+    }
+    includes(lineNumber) {
+        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
+    }
+    /**
+     * Converts this 1-based line range to a 0-based offset range (subtracts 1!).
+     * @internal
+     */
+    toOffsetRange() {
+        return new offsetRange_1.OffsetRange(this.startLineNumber - 1, this.endLineNumberExclusive - 1);
+    }
+}
+exports.LineRange = LineRange;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js":
+/*!****************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js ***!
+  \****************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.OffsetRangeSet = exports.OffsetRange = void 0;
+const errors_1 = __webpack_require__(/*! ../../../base/common/errors */ "./node_modules/vscode-diff/dist/vs/base/common/errors.js");
+/**
+ * A range of offsets (0-based).
+*/
+class OffsetRange {
+    static addRange(range, sortedRanges) {
+        let i = 0;
+        while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) {
+            i++;
+        }
+        let j = i;
+        while (j < sortedRanges.length && sortedRanges[j].start <= range.endExclusive) {
+            j++;
+        }
+        if (i === j) {
+            sortedRanges.splice(i, 0, range);
+        }
+        else {
+            const start = Math.min(range.start, sortedRanges[i].start);
+            const end = Math.max(range.endExclusive, sortedRanges[j - 1].endExclusive);
+            sortedRanges.splice(i, j - i, new OffsetRange(start, end));
+        }
+    }
+    static tryCreate(start, endExclusive) {
+        if (start > endExclusive) {
+            return undefined;
+        }
+        return new OffsetRange(start, endExclusive);
+    }
+    static ofLength(length) {
+        return new OffsetRange(0, length);
+    }
+    constructor(start, endExclusive) {
+        this.start = start;
+        this.endExclusive = endExclusive;
+        if (start > endExclusive) {
+            throw new errors_1.BugIndicatingError(`Invalid range: ${this.toString()}`);
+        }
+    }
+    get isEmpty() {
+        return this.start === this.endExclusive;
+    }
+    delta(offset) {
+        return new OffsetRange(this.start + offset, this.endExclusive + offset);
+    }
+    deltaStart(offset) {
+        return new OffsetRange(this.start + offset, this.endExclusive);
+    }
+    deltaEnd(offset) {
+        return new OffsetRange(this.start, this.endExclusive + offset);
+    }
+    get length() {
+        return this.endExclusive - this.start;
+    }
+    toString() {
+        return `[${this.start}, ${this.endExclusive})`;
+    }
+    equals(other) {
+        return this.start === other.start && this.endExclusive === other.endExclusive;
+    }
+    containsRange(other) {
+        return this.start <= other.start && other.endExclusive <= this.endExclusive;
+    }
+    contains(offset) {
+        return this.start <= offset && offset < this.endExclusive;
+    }
+    /**
+     * for all numbers n: range1.contains(n) or range2.contains(n) => range1.join(range2).contains(n)
+     * The joined range is the smallest range that contains both ranges.
+     */
+    join(other) {
+        return new OffsetRange(Math.min(this.start, other.start), Math.max(this.endExclusive, other.endExclusive));
+    }
+    /**
+     * for all numbers n: range1.contains(n) and range2.contains(n) <=> range1.intersect(range2).contains(n)
+     *
+     * The resulting range is empty if the ranges do not intersect, but touch.
+     * If the ranges don't even touch, the result is undefined.
+     */
+    intersect(other) {
+        const start = Math.max(this.start, other.start);
+        const end = Math.min(this.endExclusive, other.endExclusive);
+        if (start <= end) {
+            return new OffsetRange(start, end);
+        }
+        return undefined;
+    }
+    slice(arr) {
+        return arr.slice(this.start, this.endExclusive);
+    }
+    /**
+     * Returns the given value if it is contained in this instance, otherwise the closest value that is contained.
+     * The range must not be empty.
+     */
+    clip(value) {
+        if (this.isEmpty) {
+            throw new errors_1.BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
+        }
+        return Math.max(this.start, Math.min(this.endExclusive - 1, value));
+    }
+    /**
+     * Returns `r := value + k * length` such that `r` is contained in this range.
+     * The range must not be empty.
+     *
+     * E.g. `[5, 10).clipCyclic(10) === 5`, `[5, 10).clipCyclic(11) === 6` and `[5, 10).clipCyclic(4) === 9`.
+     */
+    clipCyclic(value) {
+        if (this.isEmpty) {
+            throw new errors_1.BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
+        }
+        if (value < this.start) {
+            return this.endExclusive - ((this.start - value) % this.length);
+        }
+        if (value >= this.endExclusive) {
+            return this.start + ((value - this.start) % this.length);
+        }
+        return value;
+    }
+}
+exports.OffsetRange = OffsetRange;
+class OffsetRangeSet {
+    constructor() {
+        this._sortedRanges = [];
+    }
+    addRange(range) {
+        let i = 0;
+        while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive < range.start) {
+            i++;
+        }
+        let j = i;
+        while (j < this._sortedRanges.length && this._sortedRanges[j].start <= range.endExclusive) {
+            j++;
+        }
+        if (i === j) {
+            this._sortedRanges.splice(i, 0, range);
+        }
+        else {
+            const start = Math.min(range.start, this._sortedRanges[i].start);
+            const end = Math.max(range.endExclusive, this._sortedRanges[j - 1].endExclusive);
+            this._sortedRanges.splice(i, j - i, new OffsetRange(start, end));
+        }
+    }
+    toString() {
+        return this._sortedRanges.map(r => r.toString()).join(', ');
+    }
+    /**
+     * Returns of there is a value that is contained in this instance and the given range.
+     */
+    intersectsStrict(other) {
+        // TODO use binary search
+        let i = 0;
+        while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive <= other.start) {
+            i++;
+        }
+        return i < this._sortedRanges.length && this._sortedRanges[i].start < other.endExclusive;
+    }
+    intersectWithRange(other) {
+        // TODO use binary search + slice
+        const result = new OffsetRangeSet();
+        for (const range of this._sortedRanges) {
+            const intersection = range.intersect(other);
+            if (intersection) {
+                result.addRange(intersection);
+            }
+        }
+        return result;
+    }
+    intersectWithRangeLength(other) {
+        return this.intersectWithRange(other).length;
+    }
+    get length() {
+        return this._sortedRanges.reduce((prev, cur) => prev + cur.length, 0);
+    }
+}
+exports.OffsetRangeSet = OffsetRangeSet;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/core/position.js":
+/*!*************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/core/position.js ***!
+  \*************************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Position = void 0;
+/**
+ * A position in the editor.
+ */
+class Position {
+    constructor(lineNumber, column) {
+        this.lineNumber = lineNumber;
+        this.column = column;
+    }
+    /**
+     * Create a new position from this position.
+     *
+     * @param newLineNumber new line number
+     * @param newColumn new column
+     */
+    with(newLineNumber = this.lineNumber, newColumn = this.column) {
+        if (newLineNumber === this.lineNumber && newColumn === this.column) {
+            return this;
+        }
+        else {
+            return new Position(newLineNumber, newColumn);
+        }
+    }
+    /**
+     * Derive a new position from this position.
+     *
+     * @param deltaLineNumber line number delta
+     * @param deltaColumn column delta
+     */
+    delta(deltaLineNumber = 0, deltaColumn = 0) {
+        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);
+    }
+    /**
+     * Test if this position equals other position
+     */
+    equals(other) {
+        return Position.equals(this, other);
+    }
+    /**
+     * Test if position `a` equals position `b`
+     */
+    static equals(a, b) {
+        if (!a && !b) {
+            return true;
+        }
+        return (!!a &&
+            !!b &&
+            a.lineNumber === b.lineNumber &&
+            a.column === b.column);
+    }
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be false.
+     */
+    isBefore(other) {
+        return Position.isBefore(this, other);
+    }
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be false.
+     */
+    static isBefore(a, b) {
+        if (a.lineNumber < b.lineNumber) {
+            return true;
+        }
+        if (b.lineNumber < a.lineNumber) {
+            return false;
+        }
+        return a.column < b.column;
+    }
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be true.
+     */
+    isBeforeOrEqual(other) {
+        return Position.isBeforeOrEqual(this, other);
+    }
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be true.
+     */
+    static isBeforeOrEqual(a, b) {
+        if (a.lineNumber < b.lineNumber) {
+            return true;
+        }
+        if (b.lineNumber < a.lineNumber) {
+            return false;
+        }
+        return a.column <= b.column;
+    }
+    /**
+     * A function that compares positions, useful for sorting
+     */
+    static compare(a, b) {
+        const aLineNumber = a.lineNumber | 0;
+        const bLineNumber = b.lineNumber | 0;
+        if (aLineNumber === bLineNumber) {
+            const aColumn = a.column | 0;
+            const bColumn = b.column | 0;
+            return aColumn - bColumn;
+        }
+        return aLineNumber - bLineNumber;
+    }
+    /**
+     * Clone this position.
+     */
+    clone() {
+        return new Position(this.lineNumber, this.column);
+    }
+    /**
+     * Convert to a human-readable representation.
+     */
+    toString() {
+        return '(' + this.lineNumber + ',' + this.column + ')';
+    }
+    // ---
+    /**
+     * Create a `Position` from an `IPosition`.
+     */
+    static lift(pos) {
+        return new Position(pos.lineNumber, pos.column);
+    }
+    /**
+     * Test if `obj` is an `IPosition`.
+     */
+    static isIPosition(obj) {
+        return (obj
+            && (typeof obj.lineNumber === 'number')
+            && (typeof obj.column === 'number'));
+    }
+}
+exports.Position = Position;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/core/range.js":
+/*!**********************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/core/range.js ***!
+  \**********************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Range = void 0;
+const position_1 = __webpack_require__(/*! ./position */ "./node_modules/vscode-diff/dist/vs/editor/common/core/position.js");
+/**
+ * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)
+ */
+class Range {
+    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {
+        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {
+            this.startLineNumber = endLineNumber;
+            this.startColumn = endColumn;
+            this.endLineNumber = startLineNumber;
+            this.endColumn = startColumn;
+        }
+        else {
+            this.startLineNumber = startLineNumber;
+            this.startColumn = startColumn;
+            this.endLineNumber = endLineNumber;
+            this.endColumn = endColumn;
+        }
+    }
+    /**
+     * Test if this range is empty.
+     */
+    isEmpty() {
+        return Range.isEmpty(this);
+    }
+    /**
+     * Test if `range` is empty.
+     */
+    static isEmpty(range) {
+        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);
+    }
+    /**
+     * Test if position is in this range. If the position is at the edges, will return true.
+     */
+    containsPosition(position) {
+        return Range.containsPosition(this, position);
+    }
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return true.
+     */
+    static containsPosition(range, position) {
+        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {
+            return false;
+        }
+        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return false.
+     * @internal
+     */
+    static strictContainsPosition(range, position) {
+        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) {
+            return false;
+        }
+        if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Test if range is in this range. If the range is equal to this range, will return true.
+     */
+    containsRange(range) {
+        return Range.containsRange(this, range);
+    }
+    /**
+     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
+     */
+    static containsRange(range, otherRange) {
+        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {
+            return false;
+        }
+        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.
+     */
+    strictContainsRange(range) {
+        return Range.strictContainsRange(this, range);
+    }
+    /**
+     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.
+     */
+    static strictContainsRange(range, otherRange) {
+        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {
+            return false;
+        }
+        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    plusRange(range) {
+        return Range.plusRange(this, range);
+    }
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    static plusRange(a, b) {
+        let startLineNumber;
+        let startColumn;
+        let endLineNumber;
+        let endColumn;
+        if (b.startLineNumber < a.startLineNumber) {
+            startLineNumber = b.startLineNumber;
+            startColumn = b.startColumn;
+        }
+        else if (b.startLineNumber === a.startLineNumber) {
+            startLineNumber = b.startLineNumber;
+            startColumn = Math.min(b.startColumn, a.startColumn);
+        }
+        else {
+            startLineNumber = a.startLineNumber;
+            startColumn = a.startColumn;
+        }
+        if (b.endLineNumber > a.endLineNumber) {
+            endLineNumber = b.endLineNumber;
+            endColumn = b.endColumn;
+        }
+        else if (b.endLineNumber === a.endLineNumber) {
+            endLineNumber = b.endLineNumber;
+            endColumn = Math.max(b.endColumn, a.endColumn);
+        }
+        else {
+            endLineNumber = a.endLineNumber;
+            endColumn = a.endColumn;
+        }
+        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
+    }
+    /**
+     * A intersection of the two ranges.
+     */
+    intersectRanges(range) {
+        return Range.intersectRanges(this, range);
+    }
+    /**
+     * A intersection of the two ranges.
+     */
+    static intersectRanges(a, b) {
+        let resultStartLineNumber = a.startLineNumber;
+        let resultStartColumn = a.startColumn;
+        let resultEndLineNumber = a.endLineNumber;
+        let resultEndColumn = a.endColumn;
+        const otherStartLineNumber = b.startLineNumber;
+        const otherStartColumn = b.startColumn;
+        const otherEndLineNumber = b.endLineNumber;
+        const otherEndColumn = b.endColumn;
+        if (resultStartLineNumber < otherStartLineNumber) {
+            resultStartLineNumber = otherStartLineNumber;
+            resultStartColumn = otherStartColumn;
+        }
+        else if (resultStartLineNumber === otherStartLineNumber) {
+            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);
+        }
+        if (resultEndLineNumber > otherEndLineNumber) {
+            resultEndLineNumber = otherEndLineNumber;
+            resultEndColumn = otherEndColumn;
+        }
+        else if (resultEndLineNumber === otherEndLineNumber) {
+            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);
+        }
+        // Check if selection is now empty
+        if (resultStartLineNumber > resultEndLineNumber) {
+            return null;
+        }
+        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {
+            return null;
+        }
+        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);
+    }
+    /**
+     * Test if this range equals other.
+     */
+    equalsRange(other) {
+        return Range.equalsRange(this, other);
+    }
+    /**
+     * Test if range `a` equals `b`.
+     */
+    static equalsRange(a, b) {
+        if (!a && !b) {
+            return true;
+        }
+        return (!!a &&
+            !!b &&
+            a.startLineNumber === b.startLineNumber &&
+            a.startColumn === b.startColumn &&
+            a.endLineNumber === b.endLineNumber &&
+            a.endColumn === b.endColumn);
+    }
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    getEndPosition() {
+        return Range.getEndPosition(this);
+    }
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    static getEndPosition(range) {
+        return new position_1.Position(range.endLineNumber, range.endColumn);
+    }
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    getStartPosition() {
+        return Range.getStartPosition(this);
+    }
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    static getStartPosition(range) {
+        return new position_1.Position(range.startLineNumber, range.startColumn);
+    }
+    /**
+     * Transform to a user presentable string representation.
+     */
+    toString() {
+        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';
+    }
+    /**
+     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
+     */
+    setEndPosition(endLineNumber, endColumn) {
+        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);
+    }
+    /**
+     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
+     */
+    setStartPosition(startLineNumber, startColumn) {
+        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);
+    }
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    collapseToStart() {
+        return Range.collapseToStart(this);
+    }
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    static collapseToStart(range) {
+        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);
+    }
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    collapseToEnd() {
+        return Range.collapseToEnd(this);
+    }
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    static collapseToEnd(range) {
+        return new Range(range.endLineNumber, range.endColumn, range.endLineNumber, range.endColumn);
+    }
+    /**
+     * Moves the range by the given amount of lines.
+     */
+    delta(lineCount) {
+        return new Range(this.startLineNumber + lineCount, this.startColumn, this.endLineNumber + lineCount, this.endColumn);
+    }
+    // ---
+    static fromPositions(start, end = start) {
+        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
+    }
+    static lift(range) {
+        if (!range) {
+            return null;
+        }
+        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);
+    }
+    /**
+     * Test if `obj` is an `IRange`.
+     */
+    static isIRange(obj) {
+        return (obj
+            && (typeof obj.startLineNumber === 'number')
+            && (typeof obj.startColumn === 'number')
+            && (typeof obj.endLineNumber === 'number')
+            && (typeof obj.endColumn === 'number'));
+    }
+    /**
+     * Test if the two ranges are touching in any way.
+     */
+    static areIntersectingOrTouching(a, b) {
+        // Check if `a` is before `b`
+        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {
+            return false;
+        }
+        // Check if `b` is before `a`
+        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {
+            return false;
+        }
+        // These ranges must intersect
+        return true;
+    }
+    /**
+     * Test if the two ranges are intersecting. If the ranges are touching it returns true.
+     */
+    static areIntersecting(a, b) {
+        // Check if `a` is before `b`
+        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {
+            return false;
+        }
+        // Check if `b` is before `a`
+        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {
+            return false;
+        }
+        // These ranges must intersect
+        return true;
+    }
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the startPosition and then on the endPosition
+     */
+    static compareRangesUsingStarts(a, b) {
+        if (a && b) {
+            const aStartLineNumber = a.startLineNumber | 0;
+            const bStartLineNumber = b.startLineNumber | 0;
+            if (aStartLineNumber === bStartLineNumber) {
+                const aStartColumn = a.startColumn | 0;
+                const bStartColumn = b.startColumn | 0;
+                if (aStartColumn === bStartColumn) {
+                    const aEndLineNumber = a.endLineNumber | 0;
+                    const bEndLineNumber = b.endLineNumber | 0;
+                    if (aEndLineNumber === bEndLineNumber) {
+                        const aEndColumn = a.endColumn | 0;
+                        const bEndColumn = b.endColumn | 0;
+                        return aEndColumn - bEndColumn;
+                    }
+                    return aEndLineNumber - bEndLineNumber;
+                }
+                return aStartColumn - bStartColumn;
+            }
+            return aStartLineNumber - bStartLineNumber;
+        }
+        const aExists = (a ? 1 : 0);
+        const bExists = (b ? 1 : 0);
+        return aExists - bExists;
+    }
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the endPosition and then on the startPosition
+     */
+    static compareRangesUsingEnds(a, b) {
+        if (a.endLineNumber === b.endLineNumber) {
+            if (a.endColumn === b.endColumn) {
+                if (a.startLineNumber === b.startLineNumber) {
+                    return a.startColumn - b.startColumn;
+                }
+                return a.startLineNumber - b.startLineNumber;
+            }
+            return a.endColumn - b.endColumn;
+        }
+        return a.endLineNumber - b.endLineNumber;
+    }
+    /**
+     * Test if the range spans multiple lines.
+     */
+    static spansMultipleLines(range) {
+        return range.endLineNumber > range.startLineNumber;
+    }
+    toJSON() {
+        return this;
+    }
+}
+exports.Range = Range;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/advancedLinesDiffComputer.js":
+/*!******************************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/advancedLinesDiffComputer.js ***!
+  \******************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.findFirstMonotonous = exports.findLastMonotonous = exports.LinesSliceCharSequence = exports.LineSequence = exports.getLineRangeMapping = exports.lineRangeMappingFromRangeMappings = exports.AdvancedLinesDiffComputer = void 0;
+const arrays_1 = __webpack_require__(/*! ../../../base/common/arrays */ "./node_modules/vscode-diff/dist/vs/base/common/arrays.js");
+const assert_1 = __webpack_require__(/*! ../../../base/common/assert */ "./node_modules/vscode-diff/dist/vs/base/common/assert.js");
+const collections_1 = __webpack_require__(/*! ../../../base/common/collections */ "./node_modules/vscode-diff/dist/vs/base/common/collections.js");
+const errors_1 = __webpack_require__(/*! ../../../base/common/errors */ "./node_modules/vscode-diff/dist/vs/base/common/errors.js");
+const lineRange_1 = __webpack_require__(/*! ../core/lineRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/lineRange.js");
+const offsetRange_1 = __webpack_require__(/*! ../core/offsetRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js");
+const position_1 = __webpack_require__(/*! ../core/position */ "./node_modules/vscode-diff/dist/vs/editor/common/core/position.js");
+const range_1 = __webpack_require__(/*! ../core/range */ "./node_modules/vscode-diff/dist/vs/editor/common/core/range.js");
+const diffAlgorithm_1 = __webpack_require__(/*! ../diff/algorithms/diffAlgorithm */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/diffAlgorithm.js");
+const dynamicProgrammingDiffing_1 = __webpack_require__(/*! ../diff/algorithms/dynamicProgrammingDiffing */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/dynamicProgrammingDiffing.js");
+const joinSequenceDiffs_1 = __webpack_require__(/*! ../diff/algorithms/joinSequenceDiffs */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/joinSequenceDiffs.js");
+const myersDiffAlgorithm_1 = __webpack_require__(/*! ../diff/algorithms/myersDiffAlgorithm */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/myersDiffAlgorithm.js");
+const linesDiffComputer_1 = __webpack_require__(/*! ./linesDiffComputer */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/linesDiffComputer.js");
+class AdvancedLinesDiffComputer {
+    constructor() {
+        this.dynamicProgrammingDiffing = new dynamicProgrammingDiffing_1.DynamicProgrammingDiffing();
+        this.myersDiffingAlgorithm = new myersDiffAlgorithm_1.MyersDiffAlgorithm();
+    }
+    computeDiff(originalLines, modifiedLines, options) {
+        if (originalLines.length <= 1 && (0, arrays_1.equals)(originalLines, modifiedLines, (a, b) => a === b)) {
+            return new linesDiffComputer_1.LinesDiff([], [], false);
+        }
+        if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {
+            return new linesDiffComputer_1.LinesDiff([
+                new linesDiffComputer_1.LineRangeMapping(new lineRange_1.LineRange(1, originalLines.length + 1), new lineRange_1.LineRange(1, modifiedLines.length + 1), [
+                    new linesDiffComputer_1.RangeMapping(new range_1.Range(1, 1, originalLines.length, originalLines[0].length + 1), new range_1.Range(1, 1, modifiedLines.length, modifiedLines[0].length + 1))
+                ])
+            ], [], false);
+        }
+        const timeout = options.maxComputationTimeMs === 0 ? diffAlgorithm_1.InfiniteTimeout.instance : new diffAlgorithm_1.DateTimeout(options.maxComputationTimeMs);
+        const considerWhitespaceChanges = !options.ignoreTrimWhitespace;
+        const perfectHashes = new Map();
+        function getOrCreateHash(text) {
+            let hash = perfectHashes.get(text);
+            if (hash === undefined) {
+                hash = perfectHashes.size;
+                perfectHashes.set(text, hash);
+            }
+            return hash;
+        }
+        const srcDocLines = originalLines.map((l) => getOrCreateHash(l.trim()));
+        const tgtDocLines = modifiedLines.map((l) => getOrCreateHash(l.trim()));
+        const sequence1 = new LineSequence(srcDocLines, originalLines);
+        const sequence2 = new LineSequence(tgtDocLines, modifiedLines);
+        const lineAlignmentResult = (() => {
+            if (sequence1.length + sequence2.length < 1700) {
+                // Use the improved algorithm for small files
+                return this.dynamicProgrammingDiffing.compute(sequence1, sequence2, timeout, (offset1, offset2) => originalLines[offset1] === modifiedLines[offset2]
+                    ? modifiedLines[offset2].length === 0
+                        ? 0.1
+                        : 1 + Math.log(1 + modifiedLines[offset2].length)
+                    : 0.99);
+            }
+            return this.myersDiffingAlgorithm.compute(sequence1, sequence2);
+        })();
+        let lineAlignments = lineAlignmentResult.diffs;
+        let hitTimeout = lineAlignmentResult.hitTimeout;
+        lineAlignments = (0, joinSequenceDiffs_1.optimizeSequenceDiffs)(sequence1, sequence2, lineAlignments);
+        lineAlignments = (0, joinSequenceDiffs_1.removeRandomLineMatches)(sequence1, sequence2, lineAlignments);
+        const alignments = [];
+        const scanForWhitespaceChanges = (equalLinesCount) => {
+            if (!considerWhitespaceChanges) {
+                return;
+            }
+            for (let i = 0; i < equalLinesCount; i++) {
+                const seq1Offset = seq1LastStart + i;
+                const seq2Offset = seq2LastStart + i;
+                if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) {
+                    // This is because of whitespace changes, diff these lines
+                    const characterDiffs = this.refineDiff(originalLines, modifiedLines, new diffAlgorithm_1.SequenceDiff(new offsetRange_1.OffsetRange(seq1Offset, seq1Offset + 1), new offsetRange_1.OffsetRange(seq2Offset, seq2Offset + 1)), timeout, considerWhitespaceChanges);
+                    for (const a of characterDiffs.mappings) {
+                        alignments.push(a);
+                    }
+                    if (characterDiffs.hitTimeout) {
+                        hitTimeout = true;
+                    }
+                }
+            }
+        };
+        let seq1LastStart = 0;
+        let seq2LastStart = 0;
+        for (const diff of lineAlignments) {
+            (0, assert_1.assertFn)(() => diff.seq1Range.start - seq1LastStart === diff.seq2Range.start - seq2LastStart);
+            const equalLinesCount = diff.seq1Range.start - seq1LastStart;
+            scanForWhitespaceChanges(equalLinesCount);
+            seq1LastStart = diff.seq1Range.endExclusive;
+            seq2LastStart = diff.seq2Range.endExclusive;
+            const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges);
+            if (characterDiffs.hitTimeout) {
+                hitTimeout = true;
+            }
+            for (const a of characterDiffs.mappings) {
+                alignments.push(a);
+            }
+        }
+        scanForWhitespaceChanges(originalLines.length - seq1LastStart);
+        const changes = lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines);
+        let moves = [];
+        if (options.computeMoves) {
+            moves = this.computeMoves(changes, originalLines, modifiedLines, srcDocLines, tgtDocLines, timeout, considerWhitespaceChanges);
+        }
+        // Make sure all ranges are valid
+        (0, assert_1.assertFn)(() => {
+            function validatePosition(pos, lines) {
+                if (pos.lineNumber < 1 || pos.lineNumber > lines.length) {
+                    return false;
+                }
+                const line = lines[pos.lineNumber - 1];
+                if (pos.column < 1 || pos.column > line.length + 1) {
+                    return false;
+                }
+                return true;
+            }
+            function validateRange(range, lines) {
+                if (range.startLineNumber < 1 || range.startLineNumber > lines.length + 1) {
+                    return false;
+                }
+                if (range.endLineNumberExclusive < 1 || range.endLineNumberExclusive > lines.length + 1) {
+                    return false;
+                }
+                return true;
+            }
+            for (const c of changes) {
+                if (!c.innerChanges) {
+                    return false;
+                }
+                for (const ic of c.innerChanges) {
+                    const valid = validatePosition(ic.modifiedRange.getStartPosition(), modifiedLines) && validatePosition(ic.modifiedRange.getEndPosition(), modifiedLines) &&
+                        validatePosition(ic.originalRange.getStartPosition(), originalLines) && validatePosition(ic.originalRange.getEndPosition(), originalLines);
+                    if (!valid) {
+                        return false;
+                    }
+                }
+                if (!validateRange(c.modifiedRange, modifiedLines) || !validateRange(c.originalRange, originalLines)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        return new linesDiffComputer_1.LinesDiff(changes, moves, hitTimeout);
+    }
+    computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges) {
+        const moves = [];
+        const deletions = changes
+            .filter(c => c.modifiedRange.isEmpty && c.originalRange.length >= 3)
+            .map(d => new LineRangeFragment(d.originalRange, originalLines, d));
+        const insertions = new Set(changes
+            .filter(c => c.originalRange.isEmpty && c.modifiedRange.length >= 3)
+            .map(d => new LineRangeFragment(d.modifiedRange, modifiedLines, d)));
+        const excludedChanges = new Set();
+        for (const deletion of deletions) {
+            let highestSimilarity = -1;
+            let best;
+            for (const insertion of insertions) {
+                const similarity = deletion.computeSimilarity(insertion);
+                if (similarity > highestSimilarity) {
+                    highestSimilarity = similarity;
+                    best = insertion;
+                }
+            }
+            if (highestSimilarity > 0.90 && best) {
+                insertions.delete(best);
+                moves.push(new linesDiffComputer_1.SimpleLineRangeMapping(deletion.range, best.range));
+                excludedChanges.add(deletion.source);
+                excludedChanges.add(best.source);
+            }
+            if (!timeout.isValid()) {
+                return [];
+            }
+        }
+        const original3LineHashes = new collections_1.SetMap();
+        for (const change of changes) {
+            if (excludedChanges.has(change)) {
+                continue;
+            }
+            for (let i = change.originalRange.startLineNumber; i < change.originalRange.endLineNumberExclusive - 2; i++) {
+                const key = `${hashedOriginalLines[i - 1]}:${hashedOriginalLines[i + 1 - 1]}:${hashedOriginalLines[i + 2 - 1]}`;
+                original3LineHashes.add(key, { range: new lineRange_1.LineRange(i, i + 3) });
+            }
+        }
+        const possibleMappings = [];
+        changes.sort((0, arrays_1.compareBy)(c => c.modifiedRange.startLineNumber, arrays_1.numberComparator));
+        for (const change of changes) {
+            if (excludedChanges.has(change)) {
+                continue;
+            }
+            let lastMappings = [];
+            for (let i = change.modifiedRange.startLineNumber; i < change.modifiedRange.endLineNumberExclusive - 2; i++) {
+                const key = `${hashedModifiedLines[i - 1]}:${hashedModifiedLines[i + 1 - 1]}:${hashedModifiedLines[i + 2 - 1]}`;
+                const currentModifiedRange = new lineRange_1.LineRange(i, i + 3);
+                const nextMappings = [];
+                original3LineHashes.forEach(key, ({ range }) => {
+                    for (const lastMapping of lastMappings) {
+                        // does this match extend some last match?
+                        if (lastMapping.originalLineRange.endLineNumberExclusive + 1 === range.endLineNumberExclusive &&
+                            lastMapping.modifiedLineRange.endLineNumberExclusive + 1 === currentModifiedRange.endLineNumberExclusive) {
+                            lastMapping.originalLineRange = new lineRange_1.LineRange(lastMapping.originalLineRange.startLineNumber, range.endLineNumberExclusive);
+                            lastMapping.modifiedLineRange = new lineRange_1.LineRange(lastMapping.modifiedLineRange.startLineNumber, currentModifiedRange.endLineNumberExclusive);
+                            nextMappings.push(lastMapping);
+                            return;
+                        }
+                    }
+                    const mapping = {
+                        modifiedLineRange: currentModifiedRange,
+                        originalLineRange: range,
+                    };
+                    possibleMappings.push(mapping);
+                    nextMappings.push(mapping);
+                });
+                lastMappings = nextMappings;
+            }
+            if (!timeout.isValid()) {
+                return [];
+            }
+        }
+        possibleMappings.sort((0, arrays_1.reverseOrder)((0, arrays_1.compareBy)(m => m.modifiedLineRange.length, arrays_1.numberComparator)));
+        const modifiedSet = new LineRangeSet();
+        const originalSet = new LineRangeSet();
+        for (const mapping of possibleMappings) {
+            const diffOrigToMod = mapping.modifiedLineRange.startLineNumber - mapping.originalLineRange.startLineNumber;
+            const modifiedSections = modifiedSet.subtractFrom(mapping.modifiedLineRange);
+            const originalTranslatedSections = originalSet.subtractFrom(mapping.originalLineRange).map(r => r.delta(diffOrigToMod));
+            const modifiedIntersectedSections = intersectRanges(modifiedSections, originalTranslatedSections);
+            for (const s of modifiedIntersectedSections) {
+                if (s.length < 3) {
+                    continue;
+                }
+                const modifiedLineRange = s;
+                const originalLineRange = s.delta(-diffOrigToMod);
+                moves.push(new linesDiffComputer_1.SimpleLineRangeMapping(originalLineRange, modifiedLineRange));
+                modifiedSet.addRange(modifiedLineRange);
+                originalSet.addRange(originalLineRange);
+            }
+        }
+        // join moves
+        moves.sort((0, arrays_1.compareBy)(m => m.original.startLineNumber, arrays_1.numberComparator));
+        if (moves.length === 0) {
+            return [];
+        }
+        let joinedMoves = [moves[0]];
+        for (let i = 1; i < moves.length; i++) {
+            const last = joinedMoves[joinedMoves.length - 1];
+            const current = moves[i];
+            const originalDist = current.original.startLineNumber - last.original.endLineNumberExclusive;
+            const modifiedDist = current.modified.startLineNumber - last.modified.endLineNumberExclusive;
+            const currentMoveAfterLast = originalDist >= 0 && modifiedDist >= 0;
+            if (currentMoveAfterLast && originalDist + modifiedDist <= 2) {
+                joinedMoves[joinedMoves.length - 1] = last.join(current);
+                continue;
+            }
+            const originalText = current.original.toOffsetRange().slice(originalLines).map(l => l.trim()).join('\n');
+            if (originalText.length <= 10) {
+                // Ignore small moves
+                continue;
+            }
+            joinedMoves.push(current);
+        }
+        // Ignore non moves
+        const originalChanges = MonotonousFinder.createOfSorted(changes, c => c.originalRange.endLineNumberExclusive, arrays_1.numberComparator);
+        joinedMoves = joinedMoves.filter(m => {
+            const diffBeforeOriginalMove = originalChanges.findLastItemBeforeOrEqual(m.original.startLineNumber)
+                || new linesDiffComputer_1.LineRangeMapping(new lineRange_1.LineRange(1, 1), new lineRange_1.LineRange(1, 1), []);
+            const modifiedDistToPrevDiff = m.modified.startLineNumber - diffBeforeOriginalMove.modifiedRange.endLineNumberExclusive;
+            const originalDistToPrevDiff = m.original.startLineNumber - diffBeforeOriginalMove.originalRange.endLineNumberExclusive;
+            const differentDistances = modifiedDistToPrevDiff !== originalDistToPrevDiff;
+            return differentDistances;
+        });
+        const fullMoves = joinedMoves.map(m => {
+            const moveChanges = this.refineDiff(originalLines, modifiedLines, new diffAlgorithm_1.SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange()), timeout, considerWhitespaceChanges);
+            const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, originalLines, modifiedLines, true);
+            return new linesDiffComputer_1.MovedText(m, mappings);
+        });
+        return fullMoves;
+    }
+    refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges) {
+        const slice1 = new LinesSliceCharSequence(originalLines, diff.seq1Range, considerWhitespaceChanges);
+        const slice2 = new LinesSliceCharSequence(modifiedLines, diff.seq2Range, considerWhitespaceChanges);
+        const diffResult = slice1.length + slice2.length < 500
+            ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout)
+            : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);
+        let diffs = diffResult.diffs;
+        diffs = (0, joinSequenceDiffs_1.optimizeSequenceDiffs)(slice1, slice2, diffs);
+        diffs = coverFullWords(slice1, slice2, diffs);
+        diffs = (0, joinSequenceDiffs_1.smoothenSequenceDiffs)(slice1, slice2, diffs);
+        diffs = (0, joinSequenceDiffs_1.removeRandomMatches)(slice1, slice2, diffs);
+        const result = diffs.map((d) => new linesDiffComputer_1.RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)));
+        // Assert: result applied on original should be the same as diff applied to original
+        return {
+            mappings: result,
+            hitTimeout: diffResult.hitTimeout,
+        };
+    }
+}
+exports.AdvancedLinesDiffComputer = AdvancedLinesDiffComputer;
+class MonotonousFinder {
+    static create(items, itemToDomain, domainComparator) {
+        items.sort((a, b) => domainComparator(itemToDomain(a), itemToDomain(b)));
+        return new MonotonousFinder(items, itemToDomain, domainComparator);
+    }
+    static createOfSorted(items, itemToDomain, domainComparator) {
+        return new MonotonousFinder(items, itemToDomain, domainComparator);
+    }
+    constructor(_items, _itemToDomain, _domainComparator) {
+        this._items = _items;
+        this._itemToDomain = _itemToDomain;
+        this._domainComparator = _domainComparator;
+        this._currentIdx = 0; // All values with index lower than this are smaller than or equal to _lastValue and vice versa.
+        this._lastValue = undefined; // Represents a smallest value.
+        this._hasLastValue = false;
+    }
+    /**
+     * Assumes the values are monotonously increasing.
+     */
+    findLastItemBeforeOrEqual(value) {
+        if (this._hasLastValue && arrays_1.CompareResult.isLessThan(this._domainComparator(value, this._lastValue))) {
+            // Values must be monotonously increasing
+            throw new errors_1.BugIndicatingError();
+        }
+        this._lastValue = value;
+        this._hasLastValue = true;
+        while (this._currentIdx < this._items.length
+            && arrays_1.CompareResult.isLessThanOrEqual(this._domainComparator(this._itemToDomain(this._items[this._currentIdx]), value))) {
+            this._currentIdx++;
+        }
+        return this._currentIdx === 0 ? undefined : this._items[this._currentIdx - 1];
+    }
+}
+function intersectRanges(ranges1, ranges2) {
+    const result = [];
+    let i1 = 0;
+    let i2 = 0;
+    while (i1 < ranges1.length && i2 < ranges2.length) {
+        const r1 = ranges1[i1];
+        const r2 = ranges2[i2];
+        const i = r1.intersect(r2);
+        if (i && !i.isEmpty) {
+            result.push(i);
+        }
+        if (r1.endLineNumberExclusive < r2.endLineNumberExclusive) {
+            i1++;
+        }
+        else {
+            i2++;
+        }
+    }
+    return result;
+}
+// TODO make this fast
+class LineRangeSet {
+    constructor() {
+        this._normalizedRanges = [];
+    }
+    addRange(range) {
+        // Idea: Find joinRange such that:
+        // replaceRange = _normalizedRanges.replaceRange(joinRange, range.joinAll(joinRange.map(idx => this._normalizedRanges[idx])))
+        // idx of first element that touches range or that is after range
+        const joinRangeStartIdx = mapMinusOne(this._normalizedRanges.findIndex(r => r.endLineNumberExclusive >= range.startLineNumber), this._normalizedRanges.length);
+        // idx of element after { last element that touches range or that is before range }
+        const joinRangeEndIdxExclusive = (0, arrays_1.findLastIndex)(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;
+        if (joinRangeStartIdx === joinRangeEndIdxExclusive) {
+            // If there is no element that touches range, then joinRangeStartIdx === joinRangeEndIdxExclusive and that value is the index of the element after range
+            this._normalizedRanges.splice(joinRangeStartIdx, 0, range);
+        }
+        else if (joinRangeStartIdx === joinRangeEndIdxExclusive - 1) {
+            // Else, there is an element that touches range and in this case it is both the first and last element. Thus we can replace it
+            const joinRange = this._normalizedRanges[joinRangeStartIdx];
+            this._normalizedRanges[joinRangeStartIdx] = joinRange.join(range);
+        }
+        else {
+            // First and last element are different - we need to replace the entire range
+            const joinRange = this._normalizedRanges[joinRangeStartIdx].join(this._normalizedRanges[joinRangeEndIdxExclusive - 1]).join(range);
+            this._normalizedRanges.splice(joinRangeStartIdx, joinRangeEndIdxExclusive - joinRangeStartIdx, joinRange);
+        }
+    }
+    intersects(range) {
+        for (const r of this._normalizedRanges) {
+            if (r.intersectsStrict(range)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Subtracts all ranges in this set from `range` and returns the result.
+     */
+    subtractFrom(range) {
+        // idx of first element that touches range or that is after range
+        const joinRangeStartIdx = mapMinusOne(this._normalizedRanges.findIndex(r => r.endLineNumberExclusive >= range.startLineNumber), this._normalizedRanges.length);
+        // idx of element after { last element that touches range or that is before range }
+        const joinRangeEndIdxExclusive = (0, arrays_1.findLastIndex)(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;
+        if (joinRangeStartIdx === joinRangeEndIdxExclusive) {
+            return [range];
+        }
+        const result = [];
+        let startLineNumber = range.startLineNumber;
+        for (let i = joinRangeStartIdx; i < joinRangeEndIdxExclusive; i++) {
+            const r = this._normalizedRanges[i];
+            if (r.startLineNumber > startLineNumber) {
+                result.push(new lineRange_1.LineRange(startLineNumber, r.startLineNumber));
+            }
+            startLineNumber = r.endLineNumberExclusive;
+        }
+        if (startLineNumber < range.endLineNumberExclusive) {
+            result.push(new lineRange_1.LineRange(startLineNumber, range.endLineNumberExclusive));
+        }
+        return result;
+    }
+}
+function mapMinusOne(idx, mapTo) {
+    return idx === -1 ? mapTo : idx;
+}
+function coverFullWords(sequence1, sequence2, sequenceDiffs) {
+    const additional = [];
+    let lastModifiedWord = undefined;
+    function maybePushWordToAdditional() {
+        if (!lastModifiedWord) {
+            return;
+        }
+        const originalLength1 = lastModifiedWord.s1Range.length - lastModifiedWord.deleted;
+        const originalLength2 = lastModifiedWord.s2Range.length - lastModifiedWord.added;
+        if (originalLength1 !== originalLength2) {
+            // TODO figure out why this happens
+        }
+        if (Math.max(lastModifiedWord.deleted, lastModifiedWord.added) + (lastModifiedWord.count - 1) > originalLength1) {
+            additional.push(new diffAlgorithm_1.SequenceDiff(lastModifiedWord.s1Range, lastModifiedWord.s2Range));
+        }
+        lastModifiedWord = undefined;
+    }
+    for (const s of sequenceDiffs) {
+        function processWord(s1Range, s2Range) {
+            if (!lastModifiedWord || !lastModifiedWord.s1Range.containsRange(s1Range) || !lastModifiedWord.s2Range.containsRange(s2Range)) {
+                if (lastModifiedWord && !(lastModifiedWord.s1Range.endExclusive < s1Range.start && lastModifiedWord.s2Range.endExclusive < s2Range.start)) {
+                    const s1Added = offsetRange_1.OffsetRange.tryCreate(lastModifiedWord.s1Range.endExclusive, s1Range.start);
+                    const s2Added = offsetRange_1.OffsetRange.tryCreate(lastModifiedWord.s2Range.endExclusive, s2Range.start);
+                    lastModifiedWord.deleted += s1Added?.length ?? 0;
+                    lastModifiedWord.added += s2Added?.length ?? 0;
+                    lastModifiedWord.s1Range = lastModifiedWord.s1Range.join(s1Range);
+                    lastModifiedWord.s2Range = lastModifiedWord.s2Range.join(s2Range);
+                }
+                else {
+                    maybePushWordToAdditional();
+                    lastModifiedWord = { added: 0, deleted: 0, count: 0, s1Range: s1Range, s2Range: s2Range };
+                }
+            }
+            const changedS1 = s1Range.intersect(s.seq1Range);
+            const changedS2 = s2Range.intersect(s.seq2Range);
+            lastModifiedWord.count++;
+            lastModifiedWord.deleted += changedS1?.length ?? 0;
+            lastModifiedWord.added += changedS2?.length ?? 0;
+        }
+        const w1Before = sequence1.findWordContaining(s.seq1Range.start - 1);
+        const w2Before = sequence2.findWordContaining(s.seq2Range.start - 1);
+        const w1After = sequence1.findWordContaining(s.seq1Range.endExclusive);
+        const w2After = sequence2.findWordContaining(s.seq2Range.endExclusive);
+        if (w1Before && w1After && w2Before && w2After && w1Before.equals(w1After) && w2Before.equals(w2After)) {
+            processWord(w1Before, w2Before);
+        }
+        else {
+            if (w1Before && w2Before) {
+                processWord(w1Before, w2Before);
+            }
+            if (w1After && w2After) {
+                processWord(w1After, w2After);
+            }
+        }
+    }
+    maybePushWordToAdditional();
+    const merged = mergeSequenceDiffs(sequenceDiffs, additional);
+    return merged;
+}
+function mergeSequenceDiffs(sequenceDiffs1, sequenceDiffs2) {
+    const result = [];
+    while (sequenceDiffs1.length > 0 || sequenceDiffs2.length > 0) {
+        const sd1 = sequenceDiffs1[0];
+        const sd2 = sequenceDiffs2[0];
+        let next;
+        if (sd1 && (!sd2 || sd1.seq1Range.start < sd2.seq1Range.start)) {
+            next = sequenceDiffs1.shift();
+        }
+        else {
+            next = sequenceDiffs2.shift();
+        }
+        if (result.length > 0 && result[result.length - 1].seq1Range.endExclusive >= next.seq1Range.start) {
+            result[result.length - 1] = result[result.length - 1].join(next);
+        }
+        else {
+            result.push(next);
+        }
+    }
+    return result;
+}
+function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines, dontAssertStartLine = false) {
+    const changes = [];
+    for (const g of group(alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines)), (a1, a2) => a1.originalRange.overlapOrTouch(a2.originalRange)
+        || a1.modifiedRange.overlapOrTouch(a2.modifiedRange))) {
+        const first = g[0];
+        const last = g[g.length - 1];
+        changes.push(new linesDiffComputer_1.LineRangeMapping(first.originalRange.join(last.originalRange), first.modifiedRange.join(last.modifiedRange), g.map(a => a.innerChanges[0])));
+    }
+    (0, assert_1.assertFn)(() => {
+        if (!dontAssertStartLine) {
+            if (changes.length > 0 && changes[0].originalRange.startLineNumber !== changes[0].modifiedRange.startLineNumber) {
+                return false;
+            }
+        }
+        return (0, assert_1.checkAdjacentItems)(changes, (m1, m2) => m2.originalRange.startLineNumber - m1.originalRange.endLineNumberExclusive === m2.modifiedRange.startLineNumber - m1.modifiedRange.endLineNumberExclusive &&
+            // There has to be an unchanged line in between (otherwise both diffs should have been joined)
+            m1.originalRange.endLineNumberExclusive < m2.originalRange.startLineNumber &&
+            m1.modifiedRange.endLineNumberExclusive < m2.modifiedRange.startLineNumber);
+    });
+    return changes;
+}
+exports.lineRangeMappingFromRangeMappings = lineRangeMappingFromRangeMappings;
+function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) {
+    let lineStartDelta = 0;
+    let lineEndDelta = 0;
+    // rangeMapping describes the edit that replaces `rangeMapping.originalRange` with `newText := getText(modifiedLines, rangeMapping.modifiedRange)`.
+    // original: ]xxx \n <- this line is not modified
+    // modified: ]xx  \n
+    if (rangeMapping.modifiedRange.endColumn === 1 && rangeMapping.originalRange.endColumn === 1
+        && rangeMapping.originalRange.startLineNumber + lineStartDelta <= rangeMapping.originalRange.endLineNumber
+        && rangeMapping.modifiedRange.startLineNumber + lineStartDelta <= rangeMapping.modifiedRange.endLineNumber) {
+        // We can only do this if the range is not empty yet
+        lineEndDelta = -1;
+    }
+    // original: xxx[ \n <- this line is not modified
+    // modified: xxx[ \n
+    if (rangeMapping.modifiedRange.startColumn - 1 >= modifiedLines[rangeMapping.modifiedRange.startLineNumber - 1].length
+        && rangeMapping.originalRange.startColumn - 1 >= originalLines[rangeMapping.originalRange.startLineNumber - 1].length
+        && rangeMapping.originalRange.startLineNumber <= rangeMapping.originalRange.endLineNumber + lineEndDelta
+        && rangeMapping.modifiedRange.startLineNumber <= rangeMapping.modifiedRange.endLineNumber + lineEndDelta) {
+        // We can only do this if the range is not empty yet
+        lineStartDelta = 1;
+    }
+    const originalLineRange = new lineRange_1.LineRange(rangeMapping.originalRange.startLineNumber + lineStartDelta, rangeMapping.originalRange.endLineNumber + 1 + lineEndDelta);
+    const modifiedLineRange = new lineRange_1.LineRange(rangeMapping.modifiedRange.startLineNumber + lineStartDelta, rangeMapping.modifiedRange.endLineNumber + 1 + lineEndDelta);
+    return new linesDiffComputer_1.LineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]);
+}
+exports.getLineRangeMapping = getLineRangeMapping;
+function* group(items, shouldBeGrouped) {
+    let currentGroup;
+    let last;
+    for (const item of items) {
+        if (last !== undefined && shouldBeGrouped(last, item)) {
+            currentGroup.push(item);
+        }
+        else {
+            if (currentGroup) {
+                yield currentGroup;
+            }
+            currentGroup = [item];
+        }
+        last = item;
+    }
+    if (currentGroup) {
+        yield currentGroup;
+    }
+}
+class LineSequence {
+    constructor(trimmedHash, lines) {
+        this.trimmedHash = trimmedHash;
+        this.lines = lines;
+    }
+    getElement(offset) {
+        return this.trimmedHash[offset];
+    }
+    get length() {
+        return this.trimmedHash.length;
+    }
+    getBoundaryScore(length) {
+        const indentationBefore = length === 0 ? 0 : getIndentation(this.lines[length - 1]);
+        const indentationAfter = length === this.lines.length ? 0 : getIndentation(this.lines[length]);
+        return 1000 - (indentationBefore + indentationAfter);
+    }
+    getText(range) {
+        return this.lines.slice(range.start, range.endExclusive).join('\n');
+    }
+    isStronglyEqual(offset1, offset2) {
+        return this.lines[offset1] === this.lines[offset2];
+    }
+}
+exports.LineSequence = LineSequence;
+function getIndentation(str) {
+    let i = 0;
+    while (i < str.length && (str.charCodeAt(i) === 32 /* CharCode.Space */ || str.charCodeAt(i) === 9 /* CharCode.Tab */)) {
+        i++;
+    }
+    return i;
+}
+class LinesSliceCharSequence {
+    constructor(lines, lineRange, considerWhitespaceChanges) {
+        // This slice has to have lineRange.length many \n! (otherwise diffing against an empty slice will be problematic)
+        // (Unless it covers the entire document, in that case the other slice also has to cover the entire document ands it's okay)
+        this.lines = lines;
+        this.considerWhitespaceChanges = considerWhitespaceChanges;
+        this.elements = [];
+        this.firstCharOffsetByLineMinusOne = [];
+        // To account for trimming
+        this.additionalOffsetByLine = [];
+        // If the slice covers the end, but does not start at the beginning, we include just the \n of the previous line.
+        let trimFirstLineFully = false;
+        if (lineRange.start > 0 && lineRange.endExclusive >= lines.length) {
+            lineRange = new offsetRange_1.OffsetRange(lineRange.start - 1, lineRange.endExclusive);
+            trimFirstLineFully = true;
+        }
+        this.lineRange = lineRange;
+        for (let i = this.lineRange.start; i < this.lineRange.endExclusive; i++) {
+            let line = lines[i];
+            let offset = 0;
+            if (trimFirstLineFully) {
+                offset = line.length;
+                line = '';
+                trimFirstLineFully = false;
+            }
+            else if (!considerWhitespaceChanges) {
+                const trimmedStartLine = line.trimStart();
+                offset = line.length - trimmedStartLine.length;
+                line = trimmedStartLine.trimEnd();
+            }
+            this.additionalOffsetByLine.push(offset);
+            for (let i = 0; i < line.length; i++) {
+                this.elements.push(line.charCodeAt(i));
+            }
+            // Don't add an \n that does not exist in the document.
+            if (i < lines.length - 1) {
+                this.elements.push('\n'.charCodeAt(0));
+                this.firstCharOffsetByLineMinusOne[i - this.lineRange.start] = this.elements.length;
+            }
+        }
+        // To account for the last line
+        this.additionalOffsetByLine.push(0);
+    }
+    toString() {
+        return `Slice: "${this.text}"`;
+    }
+    get text() {
+        return this.getText(new offsetRange_1.OffsetRange(0, this.length));
+    }
+    getText(range) {
+        return this.elements.slice(range.start, range.endExclusive).map(e => String.fromCharCode(e)).join('');
+    }
+    getElement(offset) {
+        return this.elements[offset];
+    }
+    get length() {
+        return this.elements.length;
+    }
+    getBoundaryScore(length) {
+        //   a   b   c   ,           d   e   f
+        // 11  0   0   12  15  6   13  0   0   11
+        const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1);
+        const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1);
+        if (prevCategory === 6 /* CharBoundaryCategory.LineBreakCR */ && nextCategory === 7 /* CharBoundaryCategory.LineBreakLF */) {
+            // don't break between \r and \n
+            return 0;
+        }
+        let score = 0;
+        if (prevCategory !== nextCategory) {
+            score += 10;
+            if (nextCategory === 1 /* CharBoundaryCategory.WordUpper */) {
+                score += 1;
+            }
+        }
+        score += getCategoryBoundaryScore(prevCategory);
+        score += getCategoryBoundaryScore(nextCategory);
+        return score;
+    }
+    translateOffset(offset) {
+        // find smallest i, so that lineBreakOffsets[i] <= offset using binary search
+        if (this.lineRange.isEmpty) {
+            return new position_1.Position(this.lineRange.start + 1, 1);
+        }
+        let i = 0;
+        let j = this.firstCharOffsetByLineMinusOne.length;
+        while (i < j) {
+            const k = Math.floor((i + j) / 2);
+            if (this.firstCharOffsetByLineMinusOne[k] > offset) {
+                j = k;
+            }
+            else {
+                i = k + 1;
+            }
+        }
+        const offsetOfFirstCharInLine = i === 0 ? 0 : this.firstCharOffsetByLineMinusOne[i - 1];
+        return new position_1.Position(this.lineRange.start + i + 1, offset - offsetOfFirstCharInLine + 1 + this.additionalOffsetByLine[i]);
+    }
+    translateRange(range) {
+        return range_1.Range.fromPositions(this.translateOffset(range.start), this.translateOffset(range.endExclusive));
+    }
+    /**
+     * Finds the word that contains the character at the given offset
+     */
+    findWordContaining(offset) {
+        if (offset < 0 || offset >= this.elements.length) {
+            return undefined;
+        }
+        if (!isWordChar(this.elements[offset])) {
+            return undefined;
+        }
+        // find start
+        let start = offset;
+        while (start > 0 && isWordChar(this.elements[start - 1])) {
+            start--;
+        }
+        // find end
+        let end = offset;
+        while (end < this.elements.length && isWordChar(this.elements[end])) {
+            end++;
+        }
+        return new offsetRange_1.OffsetRange(start, end);
+    }
+    countLinesIn(range) {
+        return this.translateOffset(range.endExclusive).lineNumber - this.translateOffset(range.start).lineNumber;
+    }
+    isStronglyEqual(offset1, offset2) {
+        return this.elements[offset1] === this.elements[offset2];
+    }
+    extendToFullLines(range) {
+        const start = findLastMonotonous(this.firstCharOffsetByLineMinusOne, x => x <= range.start) ?? 0;
+        const end = findFirstMonotonous(this.firstCharOffsetByLineMinusOne, x => range.endExclusive <= x) ?? this.elements.length;
+        return new offsetRange_1.OffsetRange(start, end);
+    }
+}
+exports.LinesSliceCharSequence = LinesSliceCharSequence;
+/**
+ * `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!
+ *
+ * @returns -1 if predicate is false for all items
+ */
+function findLastIdxMonotonous(arr, predicate) {
+    let i = 0;
+    let j = arr.length;
+    while (i < j) {
+        const k = Math.floor((i + j) / 2);
+        if (predicate(arr[k])) {
+            i = k + 1;
+        }
+        else {
+            j = k;
+        }
+    }
+    return i - 1;
+}
+function findLastMonotonous(arr, predicate) {
+    const idx = findLastIdxMonotonous(arr, predicate);
+    return idx === -1 ? undefined : arr[idx];
+}
+exports.findLastMonotonous = findLastMonotonous;
+/**
+ * `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!
+ *
+ * @returns arr.length if predicate is false for all items
+ */
+function findFirstIdxMonotonous(arr, predicate) {
+    let i = 0;
+    let j = arr.length;
+    while (i < j) {
+        const k = Math.floor((i + j) / 2);
+        if (predicate(arr[k])) {
+            j = k;
+        }
+        else {
+            i = k + 1;
+        }
+    }
+    return i;
+}
+function findFirstMonotonous(arr, predicate) {
+    const idx = findFirstIdxMonotonous(arr, predicate);
+    return idx === arr.length ? undefined : arr[idx];
+}
+exports.findFirstMonotonous = findFirstMonotonous;
+function isWordChar(charCode) {
+    return charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */
+        || charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */
+        || charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */;
+}
+const score = {
+    [0 /* CharBoundaryCategory.WordLower */]: 0,
+    [1 /* CharBoundaryCategory.WordUpper */]: 0,
+    [2 /* CharBoundaryCategory.WordNumber */]: 0,
+    [3 /* CharBoundaryCategory.End */]: 10,
+    [4 /* CharBoundaryCategory.Other */]: 2,
+    [5 /* CharBoundaryCategory.Space */]: 3,
+    [6 /* CharBoundaryCategory.LineBreakCR */]: 10,
+    [7 /* CharBoundaryCategory.LineBreakLF */]: 10,
+};
+function getCategoryBoundaryScore(category) {
+    return score[category];
+}
+function getCategory(charCode) {
+    if (charCode === 10 /* CharCode.LineFeed */) {
+        return 7 /* CharBoundaryCategory.LineBreakLF */;
+    }
+    else if (charCode === 13 /* CharCode.CarriageReturn */) {
+        return 6 /* CharBoundaryCategory.LineBreakCR */;
+    }
+    else if (isSpace(charCode)) {
+        return 5 /* CharBoundaryCategory.Space */;
+    }
+    else if (charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */) {
+        return 0 /* CharBoundaryCategory.WordLower */;
+    }
+    else if (charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */) {
+        return 1 /* CharBoundaryCategory.WordUpper */;
+    }
+    else if (charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */) {
+        return 2 /* CharBoundaryCategory.WordNumber */;
+    }
+    else if (charCode === -1) {
+        return 3 /* CharBoundaryCategory.End */;
+    }
+    else {
+        return 4 /* CharBoundaryCategory.Other */;
+    }
+}
+function isSpace(charCode) {
+    return charCode === 32 /* CharCode.Space */ || charCode === 9 /* CharCode.Tab */;
+}
+const chrKeys = new Map();
+function getKey(chr) {
+    let key = chrKeys.get(chr);
+    if (key === undefined) {
+        key = chrKeys.size;
+        chrKeys.set(chr, key);
+    }
+    return key;
+}
+class LineRangeFragment {
+    constructor(range, lines, source) {
+        this.range = range;
+        this.lines = lines;
+        this.source = source;
+        this.histogram = [];
+        let counter = 0;
+        for (let i = range.startLineNumber - 1; i < range.endLineNumberExclusive - 1; i++) {
+            const line = lines[i];
+            for (let j = 0; j < line.length; j++) {
+                counter++;
+                const chr = line[j];
+                const key = getKey(chr);
+                this.histogram[key] = (this.histogram[key] || 0) + 1;
+            }
+            counter++;
+            const key = getKey('\n');
+            this.histogram[key] = (this.histogram[key] || 0) + 1;
+        }
+        this.totalCount = counter;
+    }
+    computeSimilarity(other) {
+        let sumDifferences = 0;
+        const maxLength = Math.max(this.histogram.length, other.histogram.length);
+        for (let i = 0; i < maxLength; i++) {
+            sumDifferences += Math.abs((this.histogram[i] ?? 0) - (other.histogram[i] ?? 0));
+        }
+        return 1 - (sumDifferences / (this.totalCount + other.totalCount));
+    }
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/diffAlgorithm.js":
+/*!*****************************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/diffAlgorithm.js ***!
+  \*****************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DateTimeout = exports.InfiniteTimeout = exports.SequenceDiff = exports.DiffAlgorithmResult = void 0;
+const errors_1 = __webpack_require__(/*! ../../../../base/common/errors */ "./node_modules/vscode-diff/dist/vs/base/common/errors.js");
+const offsetRange_1 = __webpack_require__(/*! ../../core/offsetRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js");
+class DiffAlgorithmResult {
+    static trivial(seq1, seq2) {
+        return new DiffAlgorithmResult([new SequenceDiff(new offsetRange_1.OffsetRange(0, seq1.length), new offsetRange_1.OffsetRange(0, seq2.length))], false);
+    }
+    static trivialTimedOut(seq1, seq2) {
+        return new DiffAlgorithmResult([new SequenceDiff(new offsetRange_1.OffsetRange(0, seq1.length), new offsetRange_1.OffsetRange(0, seq2.length))], true);
+    }
+    constructor(diffs, 
+    /**
+     * Indicates if the time out was reached.
+     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
+     */
+    hitTimeout) {
+        this.diffs = diffs;
+        this.hitTimeout = hitTimeout;
+    }
+}
+exports.DiffAlgorithmResult = DiffAlgorithmResult;
+class SequenceDiff {
+    constructor(seq1Range, seq2Range) {
+        this.seq1Range = seq1Range;
+        this.seq2Range = seq2Range;
+    }
+    reverse() {
+        return new SequenceDiff(this.seq2Range, this.seq1Range);
+    }
+    toString() {
+        return `${this.seq1Range} <-> ${this.seq2Range}`;
+    }
+    join(other) {
+        return new SequenceDiff(this.seq1Range.join(other.seq1Range), this.seq2Range.join(other.seq2Range));
+    }
+    delta(offset) {
+        if (offset === 0) {
+            return this;
+        }
+        return new SequenceDiff(this.seq1Range.delta(offset), this.seq2Range.delta(offset));
+    }
+}
+exports.SequenceDiff = SequenceDiff;
+class InfiniteTimeout {
+    isValid() {
+        return true;
+    }
+}
+exports.InfiniteTimeout = InfiniteTimeout;
+InfiniteTimeout.instance = new InfiniteTimeout();
+class DateTimeout {
+    constructor(timeout) {
+        this.timeout = timeout;
+        this.startTime = Date.now();
+        this.valid = true;
+        if (timeout <= 0) {
+            throw new errors_1.BugIndicatingError('timeout must be positive');
+        }
+    }
+    // Recommendation: Set a log-point `{this.disable()}` in the body
+    isValid() {
+        const valid = Date.now() - this.startTime < this.timeout;
+        if (!valid && this.valid) {
+            this.valid = false; // timeout reached
+            // eslint-disable-next-line no-debugger
+            debugger; // WARNING: Most likely debugging caused the timeout. Call `this.disable()` to continue without timing out.
+        }
+        return this.valid;
+    }
+    disable() {
+        this.timeout = Number.MAX_SAFE_INTEGER;
+        this.isValid = () => true;
+        this.valid = true;
+    }
+}
+exports.DateTimeout = DateTimeout;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/dynamicProgrammingDiffing.js":
+/*!*****************************************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/dynamicProgrammingDiffing.js ***!
+  \*****************************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DynamicProgrammingDiffing = void 0;
+const offsetRange_1 = __webpack_require__(/*! ../../core/offsetRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js");
+const diffAlgorithm_1 = __webpack_require__(/*! ./diffAlgorithm */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/diffAlgorithm.js");
+const utils_1 = __webpack_require__(/*! ./utils */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/utils.js");
+/**
+ * A O(MN) diffing algorithm that supports a score function.
+ * The algorithm can be improved by processing the 2d array diagonally.
+*/
+class DynamicProgrammingDiffing {
+    compute(sequence1, sequence2, timeout = diffAlgorithm_1.InfiniteTimeout.instance, equalityScore) {
+        if (sequence1.length === 0 || sequence2.length === 0) {
+            return diffAlgorithm_1.DiffAlgorithmResult.trivial(sequence1, sequence2);
+        }
+        /**
+         * lcsLengths.get(i, j): Length of the longest common subsequence of sequence1.substring(0, i + 1) and sequence2.substring(0, j + 1).
+         */
+        const lcsLengths = new utils_1.Array2D(sequence1.length, sequence2.length);
+        const directions = new utils_1.Array2D(sequence1.length, sequence2.length);
+        const lengths = new utils_1.Array2D(sequence1.length, sequence2.length);
+        // ==== Initializing lcsLengths ====
+        for (let s1 = 0; s1 < sequence1.length; s1++) {
+            for (let s2 = 0; s2 < sequence2.length; s2++) {
+                if (!timeout.isValid()) {
+                    return diffAlgorithm_1.DiffAlgorithmResult.trivialTimedOut(sequence1, sequence2);
+                }
+                const horizontalLen = s1 === 0 ? 0 : lcsLengths.get(s1 - 1, s2);
+                const verticalLen = s2 === 0 ? 0 : lcsLengths.get(s1, s2 - 1);
+                let extendedSeqScore;
+                if (sequence1.getElement(s1) === sequence2.getElement(s2)) {
+                    if (s1 === 0 || s2 === 0) {
+                        extendedSeqScore = 0;
+                    }
+                    else {
+                        extendedSeqScore = lcsLengths.get(s1 - 1, s2 - 1);
+                    }
+                    if (s1 > 0 && s2 > 0 && directions.get(s1 - 1, s2 - 1) === 3) {
+                        // Prefer consecutive diagonals
+                        extendedSeqScore += lengths.get(s1 - 1, s2 - 1);
+                    }
+                    extendedSeqScore += (equalityScore ? equalityScore(s1, s2) : 1);
+                }
+                else {
+                    extendedSeqScore = -1;
+                }
+                const newValue = Math.max(horizontalLen, verticalLen, extendedSeqScore);
+                if (newValue === extendedSeqScore) {
+                    // Prefer diagonals
+                    const prevLen = s1 > 0 && s2 > 0 ? lengths.get(s1 - 1, s2 - 1) : 0;
+                    lengths.set(s1, s2, prevLen + 1);
+                    directions.set(s1, s2, 3);
+                }
+                else if (newValue === horizontalLen) {
+                    lengths.set(s1, s2, 0);
+                    directions.set(s1, s2, 1);
+                }
+                else if (newValue === verticalLen) {
+                    lengths.set(s1, s2, 0);
+                    directions.set(s1, s2, 2);
+                }
+                lcsLengths.set(s1, s2, newValue);
+            }
+        }
+        // ==== Backtracking ====
+        const result = [];
+        let lastAligningPosS1 = sequence1.length;
+        let lastAligningPosS2 = sequence2.length;
+        function reportDecreasingAligningPositions(s1, s2) {
+            if (s1 + 1 !== lastAligningPosS1 || s2 + 1 !== lastAligningPosS2) {
+                result.push(new diffAlgorithm_1.SequenceDiff(new offsetRange_1.OffsetRange(s1 + 1, lastAligningPosS1), new offsetRange_1.OffsetRange(s2 + 1, lastAligningPosS2)));
+            }
+            lastAligningPosS1 = s1;
+            lastAligningPosS2 = s2;
+        }
+        let s1 = sequence1.length - 1;
+        let s2 = sequence2.length - 1;
+        while (s1 >= 0 && s2 >= 0) {
+            if (directions.get(s1, s2) === 3) {
+                reportDecreasingAligningPositions(s1, s2);
+                s1--;
+                s2--;
+            }
+            else {
+                if (directions.get(s1, s2) === 1) {
+                    s1--;
+                }
+                else {
+                    s2--;
+                }
+            }
+        }
+        reportDecreasingAligningPositions(-1, -1);
+        result.reverse();
+        return new diffAlgorithm_1.DiffAlgorithmResult(result, false);
+    }
+}
+exports.DynamicProgrammingDiffing = DynamicProgrammingDiffing;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/joinSequenceDiffs.js":
+/*!*********************************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/joinSequenceDiffs.js ***!
+  \*********************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.shiftSequenceDiffs = exports.joinSequenceDiffs = exports.removeRandomMatches = exports.removeRandomLineMatches = exports.smoothenSequenceDiffs = exports.optimizeSequenceDiffs = void 0;
+const offsetRange_1 = __webpack_require__(/*! ../../core/offsetRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js");
+const diffAlgorithm_1 = __webpack_require__(/*! ../algorithms/diffAlgorithm */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/diffAlgorithm.js");
+function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
+    let result = sequenceDiffs;
+    result = joinSequenceDiffs(sequence1, sequence2, result);
+    result = shiftSequenceDiffs(sequence1, sequence2, result);
+    return result;
+}
+exports.optimizeSequenceDiffs = optimizeSequenceDiffs;
+function smoothenSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
+    const result = [];
+    for (const s of sequenceDiffs) {
+        const last = result[result.length - 1];
+        if (!last) {
+            result.push(s);
+            continue;
+        }
+        if (s.seq1Range.start - last.seq1Range.endExclusive <= 2 || s.seq2Range.start - last.seq2Range.endExclusive <= 2) {
+            result[result.length - 1] = new diffAlgorithm_1.SequenceDiff(last.seq1Range.join(s.seq1Range), last.seq2Range.join(s.seq2Range));
+        }
+        else {
+            result.push(s);
+        }
+    }
+    return result;
+}
+exports.smoothenSequenceDiffs = smoothenSequenceDiffs;
+function removeRandomLineMatches(sequence1, _sequence2, sequenceDiffs) {
+    let diffs = sequenceDiffs;
+    if (diffs.length === 0) {
+        return diffs;
+    }
+    let counter = 0;
+    let shouldRepeat;
+    do {
+        shouldRepeat = false;
+        const result = [
+            diffs[0]
+        ];
+        for (let i = 1; i < diffs.length; i++) {
+            const cur = diffs[i];
+            const lastResult = result[result.length - 1];
+            function shouldJoinDiffs(before, after) {
+                const unchangedRange = new offsetRange_1.OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);
+                const unchangedText = sequence1.getText(unchangedRange);
+                const unchangedTextWithoutWs = unchangedText.replace(/\s/g, '');
+                if (unchangedTextWithoutWs.length <= 4
+                    && (before.seq1Range.length + before.seq2Range.length > 5 || after.seq1Range.length + after.seq2Range.length > 5)) {
+                    return true;
+                }
+                return false;
+            }
+            const shouldJoin = shouldJoinDiffs(lastResult, cur);
+            if (shouldJoin) {
+                shouldRepeat = true;
+                result[result.length - 1] = result[result.length - 1].join(cur);
+            }
+            else {
+                result.push(cur);
+            }
+        }
+        diffs = result;
+    } while (counter++ < 10 && shouldRepeat);
+    return diffs;
+}
+exports.removeRandomLineMatches = removeRandomLineMatches;
+function removeRandomMatches(sequence1, sequence2, sequenceDiffs) {
+    let diffs = sequenceDiffs;
+    if (diffs.length === 0) {
+        return diffs;
+    }
+    let counter = 0;
+    let shouldRepeat;
+    do {
+        shouldRepeat = false;
+        const result = [
+            diffs[0]
+        ];
+        for (let i = 1; i < diffs.length; i++) {
+            const cur = diffs[i];
+            const lastResult = result[result.length - 1];
+            function shouldJoinDiffs(before, after) {
+                const unchangedRange = new offsetRange_1.OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);
+                const unchangedLineCount = sequence1.countLinesIn(unchangedRange);
+                if (unchangedLineCount > 5 || unchangedRange.length > 500) {
+                    return false;
+                }
+                const unchangedText = sequence1.getText(unchangedRange).trim();
+                if (unchangedText.length > 20 || unchangedText.split(/\r\n|\r|\n/).length > 1) {
+                    return false;
+                }
+                const beforeLineCount1 = sequence1.countLinesIn(before.seq1Range);
+                const beforeSeq1Length = before.seq1Range.length;
+                const beforeLineCount2 = sequence2.countLinesIn(before.seq2Range);
+                const beforeSeq2Length = before.seq2Range.length;
+                const afterLineCount1 = sequence1.countLinesIn(after.seq1Range);
+                const afterSeq1Length = after.seq1Range.length;
+                const afterLineCount2 = sequence2.countLinesIn(after.seq2Range);
+                const afterSeq2Length = after.seq2Range.length;
+                // TODO: Maybe a neural net can be used to derive the result from these numbers
+                const max = 2 * 40 + 50;
+                function cap(v) {
+                    return Math.min(v, max);
+                }
+                if (Math.pow(Math.pow(cap(beforeLineCount1 * 40 + beforeSeq1Length), 1.5) + Math.pow(cap(beforeLineCount2 * 40 + beforeSeq2Length), 1.5), 1.5)
+                    + Math.pow(Math.pow(cap(afterLineCount1 * 40 + afterSeq1Length), 1.5) + Math.pow(cap(afterLineCount2 * 40 + afterSeq2Length), 1.5), 1.5) > ((max ** 1.5) ** 1.5) * 1.3) {
+                    return true;
+                }
+                return false;
+            }
+            const shouldJoin = shouldJoinDiffs(lastResult, cur);
+            if (shouldJoin) {
+                shouldRepeat = true;
+                result[result.length - 1] = result[result.length - 1].join(cur);
+            }
+            else {
+                result.push(cur);
+            }
+        }
+        diffs = result;
+    } while (counter++ < 10 && shouldRepeat);
+    // Remove short suffixes/prefixes
+    for (let i = 0; i < diffs.length; i++) {
+        const cur = diffs[i];
+        let range1 = cur.seq1Range;
+        let range2 = cur.seq2Range;
+        const fullRange1 = sequence1.extendToFullLines(cur.seq1Range);
+        const prefix = sequence1.getText(new offsetRange_1.OffsetRange(fullRange1.start, cur.seq1Range.start));
+        if (prefix.length > 0 && prefix.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100) {
+            range1 = cur.seq1Range.deltaStart(-prefix.length);
+            range2 = cur.seq2Range.deltaStart(-prefix.length);
+        }
+        const suffix = sequence1.getText(new offsetRange_1.OffsetRange(cur.seq1Range.endExclusive, fullRange1.endExclusive));
+        if (suffix.length > 0 && (suffix.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 150)) {
+            range1 = range1.deltaEnd(suffix.length);
+            range2 = range2.deltaEnd(suffix.length);
+        }
+        diffs[i] = new diffAlgorithm_1.SequenceDiff(range1, range2);
+    }
+    return diffs;
+}
+exports.removeRandomMatches = removeRandomMatches;
+/**
+ * This function fixes issues like this:
+ * ```
+ * import { Baz, Bar } from "foo";
+ * ```
+ * <->
+ * ```
+ * import { Baz, Bar, Foo } from "foo";
+ * ```
+ * Computed diff: [ {Add "," after Bar}, {Add "Foo " after space} }
+ * Improved diff: [{Add ", Foo" after Bar}]
+ */
+function joinSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
+    if (sequenceDiffs.length === 0) {
+        return sequenceDiffs;
+    }
+    const result = [];
+    result.push(sequenceDiffs[0]);
+    // First move them all to the left as much as possible and join them if possible
+    for (let i = 1; i < sequenceDiffs.length; i++) {
+        const prevResult = result[result.length - 1];
+        let cur = sequenceDiffs[i];
+        if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {
+            const length = cur.seq1Range.start - prevResult.seq1Range.endExclusive;
+            let d;
+            for (d = 1; d <= length; d++) {
+                if (sequence1.getElement(cur.seq1Range.start - d) !== sequence1.getElement(cur.seq1Range.endExclusive - d) ||
+                    sequence2.getElement(cur.seq2Range.start - d) !== sequence2.getElement(cur.seq2Range.endExclusive - d)) {
+                    break;
+                }
+            }
+            d--;
+            if (d === length) {
+                // Merge previous and current diff
+                result[result.length - 1] = new diffAlgorithm_1.SequenceDiff(new offsetRange_1.OffsetRange(prevResult.seq1Range.start, cur.seq1Range.endExclusive - length), new offsetRange_1.OffsetRange(prevResult.seq2Range.start, cur.seq2Range.endExclusive - length));
+                continue;
+            }
+            cur = cur.delta(-d);
+        }
+        result.push(cur);
+    }
+    const result2 = [];
+    // Then move them all to the right and join them again if possible
+    for (let i = 0; i < result.length - 1; i++) {
+        const nextResult = result[i + 1];
+        let cur = result[i];
+        if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {
+            const length = nextResult.seq1Range.start - cur.seq1Range.endExclusive;
+            let d;
+            for (d = 0; d < length; d++) {
+                if (sequence1.getElement(cur.seq1Range.start + d) !== sequence1.getElement(cur.seq1Range.endExclusive + d) ||
+                    sequence2.getElement(cur.seq2Range.start + d) !== sequence2.getElement(cur.seq2Range.endExclusive + d)) {
+                    break;
+                }
+            }
+            if (d === length) {
+                // Merge previous and current diff, write to result!
+                result[i + 1] = new diffAlgorithm_1.SequenceDiff(new offsetRange_1.OffsetRange(cur.seq1Range.start + length, nextResult.seq1Range.endExclusive), new offsetRange_1.OffsetRange(cur.seq2Range.start + length, nextResult.seq2Range.endExclusive));
+                continue;
+            }
+            if (d > 0) {
+                cur = cur.delta(d);
+            }
+        }
+        result2.push(cur);
+    }
+    if (result.length > 0) {
+        result2.push(result[result.length - 1]);
+    }
+    return result2;
+}
+exports.joinSequenceDiffs = joinSequenceDiffs;
+// align character level diffs at whitespace characters
+// import { IBar } from "foo";
+// import { I[Arr, I]Bar } from "foo";
+// ->
+// import { [IArr, ]IBar } from "foo";
+// import { ITransaction, observableValue, transaction } from 'vs/base/common/observable';
+// import { ITransaction, observable[FromEvent, observable]Value, transaction } from 'vs/base/common/observable';
+// ->
+// import { ITransaction, [observableFromEvent, ]observableValue, transaction } from 'vs/base/common/observable';
+// collectBrackets(level + 1, levelPerBracketType);
+// collectBrackets(level + 1, levelPerBracket[ + 1, levelPerBracket]Type);
+// ->
+// collectBrackets(level + 1, [levelPerBracket + 1, ]levelPerBracketType);
+function shiftSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
+    if (!sequence1.getBoundaryScore || !sequence2.getBoundaryScore) {
+        return sequenceDiffs;
+    }
+    for (let i = 0; i < sequenceDiffs.length; i++) {
+        const prevDiff = (i > 0 ? sequenceDiffs[i - 1] : undefined);
+        const diff = sequenceDiffs[i];
+        const nextDiff = (i + 1 < sequenceDiffs.length ? sequenceDiffs[i + 1] : undefined);
+        const seq1ValidRange = new offsetRange_1.OffsetRange(prevDiff ? prevDiff.seq1Range.start + 1 : 0, nextDiff ? nextDiff.seq1Range.endExclusive - 1 : sequence1.length);
+        const seq2ValidRange = new offsetRange_1.OffsetRange(prevDiff ? prevDiff.seq2Range.start + 1 : 0, nextDiff ? nextDiff.seq2Range.endExclusive - 1 : sequence2.length);
+        if (diff.seq1Range.isEmpty) {
+            sequenceDiffs[i] = shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange);
+        }
+        else if (diff.seq2Range.isEmpty) {
+            sequenceDiffs[i] = shiftDiffToBetterPosition(diff.reverse(), sequence2, sequence1, seq2ValidRange, seq1ValidRange).reverse();
+        }
+    }
+    return sequenceDiffs;
+}
+exports.shiftSequenceDiffs = shiftSequenceDiffs;
+function shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange) {
+    const maxShiftLimit = 100; // To prevent performance issues
+    // don't touch previous or next!
+    let deltaBefore = 1;
+    while (diff.seq1Range.start - deltaBefore >= seq1ValidRange.start &&
+        diff.seq2Range.start - deltaBefore >= seq2ValidRange.start &&
+        sequence2.isStronglyEqual(diff.seq2Range.start - deltaBefore, diff.seq2Range.endExclusive - deltaBefore) && deltaBefore < maxShiftLimit) {
+        deltaBefore++;
+    }
+    deltaBefore--;
+    let deltaAfter = 0;
+    while (diff.seq1Range.start + deltaAfter < seq1ValidRange.endExclusive &&
+        diff.seq2Range.endExclusive + deltaAfter < seq2ValidRange.endExclusive &&
+        sequence2.isStronglyEqual(diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter) && deltaAfter < maxShiftLimit) {
+        deltaAfter++;
+    }
+    if (deltaBefore === 0 && deltaAfter === 0) {
+        return diff;
+    }
+    // Visualize `[sequence1.text, diff.seq1Range.start + deltaAfter]`
+    // and `[sequence2.text, diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter]`
+    let bestDelta = 0;
+    let bestScore = -1;
+    // find best scored delta
+    for (let delta = -deltaBefore; delta <= deltaAfter; delta++) {
+        const seq2OffsetStart = diff.seq2Range.start + delta;
+        const seq2OffsetEndExclusive = diff.seq2Range.endExclusive + delta;
+        const seq1Offset = diff.seq1Range.start + delta;
+        const score = sequence1.getBoundaryScore(seq1Offset) + sequence2.getBoundaryScore(seq2OffsetStart) + sequence2.getBoundaryScore(seq2OffsetEndExclusive);
+        if (score > bestScore) {
+            bestScore = score;
+            bestDelta = delta;
+        }
+    }
+    return diff.delta(bestDelta);
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/myersDiffAlgorithm.js":
+/*!**********************************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/myersDiffAlgorithm.js ***!
+  \**********************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MyersDiffAlgorithm = void 0;
+const offsetRange_1 = __webpack_require__(/*! ../../core/offsetRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/offsetRange.js");
+const diffAlgorithm_1 = __webpack_require__(/*! ../algorithms/diffAlgorithm */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/diffAlgorithm.js");
+/**
+ * An O(ND) diff algorithm that has a quadratic space worst-case complexity.
+*/
+class MyersDiffAlgorithm {
+    compute(seq1, seq2, timeout = diffAlgorithm_1.InfiniteTimeout.instance) {
+        // These are common special cases.
+        // The early return improves performance dramatically.
+        if (seq1.length === 0 || seq2.length === 0) {
+            return diffAlgorithm_1.DiffAlgorithmResult.trivial(seq1, seq2);
+        }
+        function getXAfterSnake(x, y) {
+            while (x < seq1.length && y < seq2.length && seq1.getElement(x) === seq2.getElement(y)) {
+                x++;
+                y++;
+            }
+            return x;
+        }
+        let d = 0;
+        // V[k]: X value of longest d-line that ends in diagonal k.
+        // d-line: path from (0,0) to (x,y) that uses exactly d non-diagonals.
+        // diagonal k: Set of points (x,y) with x-y = k.
+        const V = new FastInt32Array();
+        V.set(0, getXAfterSnake(0, 0));
+        const paths = new FastArrayNegativeIndices();
+        paths.set(0, V.get(0) === 0 ? null : new SnakePath(null, 0, 0, V.get(0)));
+        let k = 0;
+        loop: while (true) {
+            d++;
+            if (!timeout.isValid()) {
+                return diffAlgorithm_1.DiffAlgorithmResult.trivialTimedOut(seq1, seq2);
+            }
+            // The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result.
+            const lowerBound = -Math.min(d, seq2.length + (d % 2));
+            const upperBound = Math.min(d, seq1.length + (d % 2));
+            for (k = lowerBound; k <= upperBound; k += 2) {
+                // We can use the X values of (d-1)-lines to compute X value of the longest d-lines.
+                const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // We take a vertical non-diagonal (add a symbol in seq1)
+                const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x) (delete a symbol in seq1)
+                const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seq1.length);
+                const y = x - k;
+                if (x > seq1.length || y > seq2.length) {
+                    // This diagonal is irrelevant for the result.
+                    // TODO: Don't pay the cost for this in the next iteration.
+                    continue;
+                }
+                const newMaxX = getXAfterSnake(x, y);
+                V.set(k, newMaxX);
+                const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1);
+                paths.set(k, newMaxX !== x ? new SnakePath(lastPath, x, y, newMaxX - x) : lastPath);
+                if (V.get(k) === seq1.length && V.get(k) - k === seq2.length) {
+                    break loop;
+                }
+            }
+        }
+        let path = paths.get(k);
+        const result = [];
+        let lastAligningPosS1 = seq1.length;
+        let lastAligningPosS2 = seq2.length;
+        while (true) {
+            const endX = path ? path.x + path.length : 0;
+            const endY = path ? path.y + path.length : 0;
+            if (endX !== lastAligningPosS1 || endY !== lastAligningPosS2) {
+                result.push(new diffAlgorithm_1.SequenceDiff(new offsetRange_1.OffsetRange(endX, lastAligningPosS1), new offsetRange_1.OffsetRange(endY, lastAligningPosS2)));
+            }
+            if (!path) {
+                break;
+            }
+            lastAligningPosS1 = path.x;
+            lastAligningPosS2 = path.y;
+            path = path.prev;
+        }
+        result.reverse();
+        return new diffAlgorithm_1.DiffAlgorithmResult(result, false);
+    }
+}
+exports.MyersDiffAlgorithm = MyersDiffAlgorithm;
+class SnakePath {
+    constructor(prev, x, y, length) {
+        this.prev = prev;
+        this.x = x;
+        this.y = y;
+        this.length = length;
+    }
+}
+/**
+ * An array that supports fast negative indices.
+*/
+class FastInt32Array {
+    constructor() {
+        this.positiveArr = new Int32Array(10);
+        this.negativeArr = new Int32Array(10);
+    }
+    get(idx) {
+        if (idx < 0) {
+            idx = -idx - 1;
+            return this.negativeArr[idx];
+        }
+        else {
+            return this.positiveArr[idx];
+        }
+    }
+    set(idx, value) {
+        if (idx < 0) {
+            idx = -idx - 1;
+            if (idx >= this.negativeArr.length) {
+                const arr = this.negativeArr;
+                this.negativeArr = new Int32Array(arr.length * 2);
+                this.negativeArr.set(arr);
+            }
+            this.negativeArr[idx] = value;
+        }
+        else {
+            if (idx >= this.positiveArr.length) {
+                const arr = this.positiveArr;
+                this.positiveArr = new Int32Array(arr.length * 2);
+                this.positiveArr.set(arr);
+            }
+            this.positiveArr[idx] = value;
+        }
+    }
+}
+/**
+ * An array that supports fast negative indices.
+*/
+class FastArrayNegativeIndices {
+    constructor() {
+        this.positiveArr = [];
+        this.negativeArr = [];
+    }
+    get(idx) {
+        if (idx < 0) {
+            idx = -idx - 1;
+            return this.negativeArr[idx];
+        }
+        else {
+            return this.positiveArr[idx];
+        }
+    }
+    set(idx, value) {
+        if (idx < 0) {
+            idx = -idx - 1;
+            this.negativeArr[idx] = value;
+        }
+        else {
+            this.positiveArr[idx] = value;
+        }
+    }
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/utils.js":
+/*!*********************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/algorithms/utils.js ***!
+  \*********************************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Array2D = void 0;
+class Array2D {
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.array = [];
+        this.array = new Array(width * height);
+    }
+    get(x, y) {
+        return this.array[x + y * this.width];
+    }
+    set(x, y, value) {
+        this.array[x + y * this.width] = value;
+    }
+}
+exports.Array2D = Array2D;
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/legacyLinesDiffComputer.js":
+/*!****************************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/legacyLinesDiffComputer.js ***!
+  \****************************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DiffComputer = exports.LegacyLinesDiffComputer = void 0;
+const assert_1 = __webpack_require__(/*! ../../../base/common/assert */ "./node_modules/vscode-diff/dist/vs/base/common/assert.js");
+const diff_1 = __webpack_require__(/*! ../../../base/common/diff/diff */ "./node_modules/vscode-diff/dist/vs/base/common/diff/diff.js");
+const strings = __webpack_require__(/*! ../../../base/common/strings */ "./node_modules/vscode-diff/dist/vs/base/common/strings.js");
+const lineRange_1 = __webpack_require__(/*! ../core/lineRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/lineRange.js");
+const range_1 = __webpack_require__(/*! ../core/range */ "./node_modules/vscode-diff/dist/vs/editor/common/core/range.js");
+const linesDiffComputer_1 = __webpack_require__(/*! ./linesDiffComputer */ "./node_modules/vscode-diff/dist/vs/editor/common/diff/linesDiffComputer.js");
+const MINIMUM_MATCHING_CHARACTER_LENGTH = 3;
+class LegacyLinesDiffComputer {
+    computeDiff(originalLines, modifiedLines, options) {
+        const diffComputer = new DiffComputer(originalLines, modifiedLines, {
+            maxComputationTime: options.maxComputationTimeMs,
+            shouldIgnoreTrimWhitespace: options.ignoreTrimWhitespace,
+            shouldComputeCharChanges: true,
+            shouldMakePrettyDiff: true,
+            shouldPostProcessCharChanges: true,
+        });
+        const result = diffComputer.computeDiff();
+        const changes = [];
+        let lastChange = null;
+        for (const c of result.changes) {
+            let originalRange;
+            if (c.originalEndLineNumber === 0) {
+                // Insertion
+                originalRange = new lineRange_1.LineRange(c.originalStartLineNumber + 1, c.originalStartLineNumber + 1);
+            }
+            else {
+                originalRange = new lineRange_1.LineRange(c.originalStartLineNumber, c.originalEndLineNumber + 1);
+            }
+            let modifiedRange;
+            if (c.modifiedEndLineNumber === 0) {
+                // Deletion
+                modifiedRange = new lineRange_1.LineRange(c.modifiedStartLineNumber + 1, c.modifiedStartLineNumber + 1);
+            }
+            else {
+                modifiedRange = new lineRange_1.LineRange(c.modifiedStartLineNumber, c.modifiedEndLineNumber + 1);
+            }
+            let change = new linesDiffComputer_1.LineRangeMapping(originalRange, modifiedRange, c.charChanges?.map(c => new linesDiffComputer_1.RangeMapping(new range_1.Range(c.originalStartLineNumber, c.originalStartColumn, c.originalEndLineNumber, c.originalEndColumn), new range_1.Range(c.modifiedStartLineNumber, c.modifiedStartColumn, c.modifiedEndLineNumber, c.modifiedEndColumn))));
+            if (lastChange) {
+                if (lastChange.modifiedRange.endLineNumberExclusive === change.modifiedRange.startLineNumber
+                    || lastChange.originalRange.endLineNumberExclusive === change.originalRange.startLineNumber) {
+                    // join touching diffs. Probably moving diffs up/down in the algorithm causes touching diffs.
+                    change = new linesDiffComputer_1.LineRangeMapping(lastChange.originalRange.join(change.originalRange), lastChange.modifiedRange.join(change.modifiedRange), lastChange.innerChanges && change.innerChanges ?
+                        lastChange.innerChanges.concat(change.innerChanges) : undefined);
+                    changes.pop();
+                }
+            }
+            changes.push(change);
+            lastChange = change;
+        }
+        (0, assert_1.assertFn)(() => {
+            return (0, assert_1.checkAdjacentItems)(changes, (m1, m2) => m2.originalRange.startLineNumber - m1.originalRange.endLineNumberExclusive === m2.modifiedRange.startLineNumber - m1.modifiedRange.endLineNumberExclusive &&
+                // There has to be an unchanged line in between (otherwise both diffs should have been joined)
+                m1.originalRange.endLineNumberExclusive < m2.originalRange.startLineNumber &&
+                m1.modifiedRange.endLineNumberExclusive < m2.modifiedRange.startLineNumber);
+        });
+        return new linesDiffComputer_1.LinesDiff(changes, [], result.quitEarly);
+    }
+}
+exports.LegacyLinesDiffComputer = LegacyLinesDiffComputer;
+function computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {
+    const diffAlgo = new diff_1.LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);
+    return diffAlgo.ComputeDiff(pretty);
+}
+class LineSequence {
+    constructor(lines) {
+        const startColumns = [];
+        const endColumns = [];
+        for (let i = 0, length = lines.length; i < length; i++) {
+            startColumns[i] = getFirstNonBlankColumn(lines[i], 1);
+            endColumns[i] = getLastNonBlankColumn(lines[i], 1);
+        }
+        this.lines = lines;
+        this._startColumns = startColumns;
+        this._endColumns = endColumns;
+    }
+    getElements() {
+        const elements = [];
+        for (let i = 0, len = this.lines.length; i < len; i++) {
+            elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);
+        }
+        return elements;
+    }
+    getStrictElement(index) {
+        return this.lines[index];
+    }
+    getStartLineNumber(i) {
+        return i + 1;
+    }
+    getEndLineNumber(i) {
+        return i + 1;
+    }
+    createCharSequence(shouldIgnoreTrimWhitespace, startIndex, endIndex) {
+        const charCodes = [];
+        const lineNumbers = [];
+        const columns = [];
+        let len = 0;
+        for (let index = startIndex; index <= endIndex; index++) {
+            const lineContent = this.lines[index];
+            const startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);
+            const endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);
+            for (let col = startColumn; col < endColumn; col++) {
+                charCodes[len] = lineContent.charCodeAt(col - 1);
+                lineNumbers[len] = index + 1;
+                columns[len] = col;
+                len++;
+            }
+            if (!shouldIgnoreTrimWhitespace && index < endIndex) {
+                // Add \n if trim whitespace is not ignored
+                charCodes[len] = 10 /* CharCode.LineFeed */;
+                lineNumbers[len] = index + 1;
+                columns[len] = lineContent.length + 1;
+                len++;
+            }
+        }
+        return new CharSequence(charCodes, lineNumbers, columns);
+    }
+}
+class CharSequence {
+    constructor(charCodes, lineNumbers, columns) {
+        this._charCodes = charCodes;
+        this._lineNumbers = lineNumbers;
+        this._columns = columns;
+    }
+    toString() {
+        return ('[' + this._charCodes.map((s, idx) => (s === 10 /* CharCode.LineFeed */ ? '\\n' : String.fromCharCode(s)) + `-(${this._lineNumbers[idx]},${this._columns[idx]})`).join(', ') + ']');
+    }
+    _assertIndex(index, arr) {
+        if (index < 0 || index >= arr.length) {
+            throw new Error(`Illegal index`);
+        }
+    }
+    getElements() {
+        return this._charCodes;
+    }
+    getStartLineNumber(i) {
+        if (i > 0 && i === this._lineNumbers.length) {
+            // the start line number of the element after the last element
+            // is the end line number of the last element
+            return this.getEndLineNumber(i - 1);
+        }
+        this._assertIndex(i, this._lineNumbers);
+        return this._lineNumbers[i];
+    }
+    getEndLineNumber(i) {
+        if (i === -1) {
+            // the end line number of the element before the first element
+            // is the start line number of the first element
+            return this.getStartLineNumber(i + 1);
+        }
+        this._assertIndex(i, this._lineNumbers);
+        if (this._charCodes[i] === 10 /* CharCode.LineFeed */) {
+            return this._lineNumbers[i] + 1;
+        }
+        return this._lineNumbers[i];
+    }
+    getStartColumn(i) {
+        if (i > 0 && i === this._columns.length) {
+            // the start column of the element after the last element
+            // is the end column of the last element
+            return this.getEndColumn(i - 1);
+        }
+        this._assertIndex(i, this._columns);
+        return this._columns[i];
+    }
+    getEndColumn(i) {
+        if (i === -1) {
+            // the end column of the element before the first element
+            // is the start column of the first element
+            return this.getStartColumn(i + 1);
+        }
+        this._assertIndex(i, this._columns);
+        if (this._charCodes[i] === 10 /* CharCode.LineFeed */) {
+            return 1;
+        }
+        return this._columns[i] + 1;
+    }
+}
+class CharChange {
+    constructor(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {
+        this.originalStartLineNumber = originalStartLineNumber;
+        this.originalStartColumn = originalStartColumn;
+        this.originalEndLineNumber = originalEndLineNumber;
+        this.originalEndColumn = originalEndColumn;
+        this.modifiedStartLineNumber = modifiedStartLineNumber;
+        this.modifiedStartColumn = modifiedStartColumn;
+        this.modifiedEndLineNumber = modifiedEndLineNumber;
+        this.modifiedEndColumn = modifiedEndColumn;
+    }
+    static createFromDiffChange(diffChange, originalCharSequence, modifiedCharSequence) {
+        const originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);
+        const originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);
+        const originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);
+        const originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);
+        const modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);
+        const modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);
+        const modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);
+        const modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);
+        return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);
+    }
+}
+function postProcessCharChanges(rawChanges) {
+    if (rawChanges.length <= 1) {
+        return rawChanges;
+    }
+    const result = [rawChanges[0]];
+    let prevChange = result[0];
+    for (let i = 1, len = rawChanges.length; i < len; i++) {
+        const currChange = rawChanges[i];
+        const originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);
+        const modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);
+        // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true
+        const matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);
+        if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {
+            // Merge the current change into the previous one
+            prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;
+            prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;
+        }
+        else {
+            // Add the current change
+            result.push(currChange);
+            prevChange = currChange;
+        }
+    }
+    return result;
+}
+class LineChange {
+    constructor(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {
+        this.originalStartLineNumber = originalStartLineNumber;
+        this.originalEndLineNumber = originalEndLineNumber;
+        this.modifiedStartLineNumber = modifiedStartLineNumber;
+        this.modifiedEndLineNumber = modifiedEndLineNumber;
+        this.charChanges = charChanges;
+    }
+    static createFromDiffResult(shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) {
+        let originalStartLineNumber;
+        let originalEndLineNumber;
+        let modifiedStartLineNumber;
+        let modifiedEndLineNumber;
+        let charChanges = undefined;
+        if (diffChange.originalLength === 0) {
+            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;
+            originalEndLineNumber = 0;
+        }
+        else {
+            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);
+            originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);
+        }
+        if (diffChange.modifiedLength === 0) {
+            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;
+            modifiedEndLineNumber = 0;
+        }
+        else {
+            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);
+            modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);
+        }
+        if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) {
+            // Compute character changes for diff chunks of at most 20 lines...
+            const originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);
+            const modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);
+            if (originalCharSequence.getElements().length > 0 && modifiedCharSequence.getElements().length > 0) {
+                let rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes;
+                if (shouldPostProcessCharChanges) {
+                    rawChanges = postProcessCharChanges(rawChanges);
+                }
+                charChanges = [];
+                for (let i = 0, length = rawChanges.length; i < length; i++) {
+                    charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));
+                }
+            }
+        }
+        return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);
+    }
+}
+class DiffComputer {
+    constructor(originalLines, modifiedLines, opts) {
+        this.shouldComputeCharChanges = opts.shouldComputeCharChanges;
+        this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;
+        this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;
+        this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;
+        this.originalLines = originalLines;
+        this.modifiedLines = modifiedLines;
+        this.original = new LineSequence(originalLines);
+        this.modified = new LineSequence(modifiedLines);
+        this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime);
+        this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes...
+    }
+    computeDiff() {
+        if (this.original.lines.length === 1 && this.original.lines[0].length === 0) {
+            // empty original => fast path
+            if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {
+                return {
+                    quitEarly: false,
+                    changes: []
+                };
+            }
+            return {
+                quitEarly: false,
+                changes: [{
+                        originalStartLineNumber: 1,
+                        originalEndLineNumber: 1,
+                        modifiedStartLineNumber: 1,
+                        modifiedEndLineNumber: this.modified.lines.length,
+                        charChanges: undefined
+                    }]
+            };
+        }
+        if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {
+            // empty modified => fast path
+            return {
+                quitEarly: false,
+                changes: [{
+                        originalStartLineNumber: 1,
+                        originalEndLineNumber: this.original.lines.length,
+                        modifiedStartLineNumber: 1,
+                        modifiedEndLineNumber: 1,
+                        charChanges: undefined
+                    }]
+            };
+        }
+        const diffResult = computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff);
+        const rawChanges = diffResult.changes;
+        const quitEarly = diffResult.quitEarly;
+        // The diff is always computed with ignoring trim whitespace
+        // This ensures we get the prettiest diff
+        if (this.shouldIgnoreTrimWhitespace) {
+            const lineChanges = [];
+            for (let i = 0, length = rawChanges.length; i < length; i++) {
+                lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));
+            }
+            return {
+                quitEarly: quitEarly,
+                changes: lineChanges
+            };
+        }
+        // Need to post-process and introduce changes where the trim whitespace is different
+        // Note that we are looping starting at -1 to also cover the lines before the first change
+        const result = [];
+        let originalLineIndex = 0;
+        let modifiedLineIndex = 0;
+        for (let i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {
+            const nextChange = (i + 1 < len ? rawChanges[i + 1] : null);
+            const originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);
+            const modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);
+            while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {
+                const originalLine = this.originalLines[originalLineIndex];
+                const modifiedLine = this.modifiedLines[modifiedLineIndex];
+                if (originalLine !== modifiedLine) {
+                    // These lines differ only in trim whitespace
+                    // Check the leading whitespace
+                    {
+                        let originalStartColumn = getFirstNonBlankColumn(originalLine, 1);
+                        let modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1);
+                        while (originalStartColumn > 1 && modifiedStartColumn > 1) {
+                            const originalChar = originalLine.charCodeAt(originalStartColumn - 2);
+                            const modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);
+                            if (originalChar !== modifiedChar) {
+                                break;
+                            }
+                            originalStartColumn--;
+                            modifiedStartColumn--;
+                        }
+                        if (originalStartColumn > 1 || modifiedStartColumn > 1) {
+                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);
+                        }
+                    }
+                    // Check the trailing whitespace
+                    {
+                        let originalEndColumn = getLastNonBlankColumn(originalLine, 1);
+                        let modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1);
+                        const originalMaxColumn = originalLine.length + 1;
+                        const modifiedMaxColumn = modifiedLine.length + 1;
+                        while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {
+                            const originalChar = originalLine.charCodeAt(originalEndColumn - 1);
+                            const modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);
+                            if (originalChar !== modifiedChar) {
+                                break;
+                            }
+                            originalEndColumn++;
+                            modifiedEndColumn++;
+                        }
+                        if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {
+                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);
+                        }
+                    }
+                }
+                originalLineIndex++;
+                modifiedLineIndex++;
+            }
+            if (nextChange) {
+                // Emit the actual change
+                result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));
+                originalLineIndex += nextChange.originalLength;
+                modifiedLineIndex += nextChange.modifiedLength;
+            }
+        }
+        return {
+            quitEarly: quitEarly,
+            changes: result
+        };
+    }
+    _pushTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {
+        if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {
+            // Merged into previous
+            return;
+        }
+        let charChanges = undefined;
+        if (this.shouldComputeCharChanges) {
+            charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];
+        }
+        result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));
+    }
+    _mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {
+        const len = result.length;
+        if (len === 0) {
+            return false;
+        }
+        const prevChange = result[len - 1];
+        if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {
+            // Don't merge with inserts/deletes
+            return false;
+        }
+        if (prevChange.originalEndLineNumber === originalLineNumber && prevChange.modifiedEndLineNumber === modifiedLineNumber) {
+            if (this.shouldComputeCharChanges && prevChange.charChanges) {
+                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));
+            }
+            return true;
+        }
+        if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {
+            prevChange.originalEndLineNumber = originalLineNumber;
+            prevChange.modifiedEndLineNumber = modifiedLineNumber;
+            if (this.shouldComputeCharChanges && prevChange.charChanges) {
+                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));
+            }
+            return true;
+        }
+        return false;
+    }
+}
+exports.DiffComputer = DiffComputer;
+function getFirstNonBlankColumn(txt, defaultValue) {
+    const r = strings.firstNonWhitespaceIndex(txt);
+    if (r === -1) {
+        return defaultValue;
+    }
+    return r + 1;
+}
+function getLastNonBlankColumn(txt, defaultValue) {
+    const r = strings.lastNonWhitespaceIndex(txt);
+    if (r === -1) {
+        return defaultValue;
+    }
+    return r + 2;
+}
+function createContinueProcessingPredicate(maximumRuntime) {
+    if (maximumRuntime === 0) {
+        return () => true;
+    }
+    const startTime = Date.now();
+    return () => {
+        return Date.now() - startTime < maximumRuntime;
+    };
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/vscode-diff/dist/vs/editor/common/diff/linesDiffComputer.js":
+/*!**********************************************************************************!*\
+  !*** ./node_modules/vscode-diff/dist/vs/editor/common/diff/linesDiffComputer.js ***!
+  \**********************************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MovedText = exports.SimpleLineRangeMapping = exports.RangeMapping = exports.LineRangeMapping = exports.LinesDiff = void 0;
+const lineRange_1 = __webpack_require__(/*! ../core/lineRange */ "./node_modules/vscode-diff/dist/vs/editor/common/core/lineRange.js");
+class LinesDiff {
+    constructor(changes, 
+    /**
+     * Sorted by original line ranges.
+     * The original line ranges and the modified line ranges must be disjoint (but can be touching).
+     */
+    moves, 
+    /**
+     * Indicates if the time out was reached.
+     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
+     */
+    hitTimeout) {
+        this.changes = changes;
+        this.moves = moves;
+        this.hitTimeout = hitTimeout;
+    }
+}
+exports.LinesDiff = LinesDiff;
+/**
+ * Maps a line range in the original text model to a line range in the modified text model.
+ */
+class LineRangeMapping {
+    static inverse(mapping, originalLineCount, modifiedLineCount) {
+        const result = [];
+        let lastOriginalEndLineNumber = 1;
+        let lastModifiedEndLineNumber = 1;
+        for (const m of mapping) {
+            const r = new LineRangeMapping(new lineRange_1.LineRange(lastOriginalEndLineNumber, m.originalRange.startLineNumber), new lineRange_1.LineRange(lastModifiedEndLineNumber, m.modifiedRange.startLineNumber), undefined);
+            if (!r.modifiedRange.isEmpty) {
+                result.push(r);
+            }
+            lastOriginalEndLineNumber = m.originalRange.endLineNumberExclusive;
+            lastModifiedEndLineNumber = m.modifiedRange.endLineNumberExclusive;
+        }
+        const r = new LineRangeMapping(new lineRange_1.LineRange(lastOriginalEndLineNumber, originalLineCount + 1), new lineRange_1.LineRange(lastModifiedEndLineNumber, modifiedLineCount + 1), undefined);
+        if (!r.modifiedRange.isEmpty) {
+            result.push(r);
+        }
+        return result;
+    }
+    constructor(originalRange, modifiedRange, innerChanges) {
+        this.originalRange = originalRange;
+        this.modifiedRange = modifiedRange;
+        this.innerChanges = innerChanges;
+    }
+    toString() {
+        return `{${this.originalRange.toString()}->${this.modifiedRange.toString()}}`;
+    }
+    get changedLineCount() {
+        return Math.max(this.originalRange.length, this.modifiedRange.length);
+    }
+    flip() {
+        return new LineRangeMapping(this.modifiedRange, this.originalRange, this.innerChanges?.map(c => c.flip()));
+    }
+}
+exports.LineRangeMapping = LineRangeMapping;
+/**
+ * Maps a range in the original text model to a range in the modified text model.
+ */
+class RangeMapping {
+    constructor(originalRange, modifiedRange) {
+        this.originalRange = originalRange;
+        this.modifiedRange = modifiedRange;
+    }
+    toString() {
+        return `{${this.originalRange.toString()}->${this.modifiedRange.toString()}}`;
+    }
+    flip() {
+        return new RangeMapping(this.modifiedRange, this.originalRange);
+    }
+}
+exports.RangeMapping = RangeMapping;
+// TODO@hediet: Make LineRangeMapping extend from this!
+class SimpleLineRangeMapping {
+    constructor(original, modified) {
+        this.original = original;
+        this.modified = modified;
+    }
+    toString() {
+        return `{${this.original.toString()}->${this.modified.toString()}}`;
+    }
+    flip() {
+        return new SimpleLineRangeMapping(this.modified, this.original);
+    }
+    join(other) {
+        return new SimpleLineRangeMapping(this.original.join(other.original), this.modified.join(other.modified));
+    }
+}
+exports.SimpleLineRangeMapping = SimpleLineRangeMapping;
+class MovedText {
+    constructor(lineRangeMapping, changes) {
+        this.lineRangeMapping = lineRangeMapping;
+        this.changes = changes;
+    }
+    flip() {
+        return new MovedText(this.lineRangeMapping.flip(), this.changes.map(c => c.flip()));
+    }
+}
+exports.MovedText = MovedText;
+
+
+/***/ })
+
+}]);
+//# sourceMappingURL=vendors-node_modules_vscode-diff_dist_index_js.ea55f1f9346638aafbcf.js.map