@vscode/chat-lib 0.0.1

package/dist/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js

@@ -0,0 +1,213 @@
+"use strict";
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultLinesDiffComputer = void 0;
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const arrays_1 = require("../../../../base/common/arrays");
+const assert_1 = require("../../../../base/common/assert");
+const lineRange_1 = require("../../core/ranges/lineRange");
+const offsetRange_1 = require("../../core/ranges/offsetRange");
+const range_1 = require("../../core/range");
+const abstractText_1 = require("../../core/text/abstractText");
+const linesDiffComputer_1 = require("../linesDiffComputer");
+const rangeMapping_1 = require("../rangeMapping");
+const diffAlgorithm_1 = require("./algorithms/diffAlgorithm");
+const dynamicProgrammingDiffing_1 = require("./algorithms/dynamicProgrammingDiffing");
+const myersDiffAlgorithm_1 = require("./algorithms/myersDiffAlgorithm");
+const computeMovedLines_1 = require("./computeMovedLines");
+const heuristicSequenceOptimizations_1 = require("./heuristicSequenceOptimizations");
+const lineSequence_1 = require("./lineSequence");
+const linesSliceCharSequence_1 = require("./linesSliceCharSequence");
+class DefaultLinesDiffComputer {
+    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 rangeMapping_1.DetailedLineRangeMapping(new lineRange_1.LineRange(1, originalLines.length + 1), new lineRange_1.LineRange(1, modifiedLines.length + 1), [
+                    new rangeMapping_1.RangeMapping(new range_1.Range(1, 1, originalLines.length, originalLines[originalLines.length - 1].length + 1), new range_1.Range(1, 1, modifiedLines.length, modifiedLines[modifiedLines.length - 1].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 originalLinesHashes = originalLines.map((l) => getOrCreateHash(l.trim()));
+        const modifiedLinesHashes = modifiedLines.map((l) => getOrCreateHash(l.trim()));
+        const sequence1 = new lineSequence_1.LineSequence(originalLinesHashes, originalLines);
+        const sequence2 = new lineSequence_1.LineSequence(modifiedLinesHashes, 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, timeout);
+        })();
+        let lineAlignments = lineAlignmentResult.diffs;
+        let hitTimeout = lineAlignmentResult.hitTimeout;
+        lineAlignments = (0, heuristicSequenceOptimizations_1.optimizeSequenceDiffs)(sequence1, sequence2, lineAlignments);
+        lineAlignments = (0, heuristicSequenceOptimizations_1.removeVeryShortMatchingLinesBetweenDiffs)(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, options);
+                    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, options);
+            if (characterDiffs.hitTimeout) {
+                hitTimeout = true;
+            }
+            for (const a of characterDiffs.mappings) {
+                alignments.push(a);
+            }
+        }
+        scanForWhitespaceChanges(originalLines.length - seq1LastStart);
+        const original = new abstractText_1.ArrayText(originalLines);
+        const modified = new abstractText_1.ArrayText(modifiedLines);
+        const changes = (0, rangeMapping_1.lineRangeMappingFromRangeMappings)(alignments, original, modified);
+        let moves = [];
+        if (options.computeMoves) {
+            moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges, options);
+        }
+        // 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.modified, modifiedLines) || !validateRange(c.original, originalLines)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        return new linesDiffComputer_1.LinesDiff(changes, moves, hitTimeout);
+    }
+    computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges, options) {
+        const moves = (0, computeMovedLines_1.computeMovedLines)(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout);
+        const movesWithDiffs = moves.map(m => {
+            const moveChanges = this.refineDiff(originalLines, modifiedLines, new diffAlgorithm_1.SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange()), timeout, considerWhitespaceChanges, options);
+            const mappings = (0, rangeMapping_1.lineRangeMappingFromRangeMappings)(moveChanges.mappings, new abstractText_1.ArrayText(originalLines), new abstractText_1.ArrayText(modifiedLines), true);
+            return new linesDiffComputer_1.MovedText(m, mappings);
+        });
+        return movesWithDiffs;
+    }
+    refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options) {
+        const lineRangeMapping = toLineRangeMapping(diff);
+        const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
+        const slice1 = new linesSliceCharSequence_1.LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges);
+        const slice2 = new linesSliceCharSequence_1.LinesSliceCharSequence(modifiedLines, rangeMapping.modifiedRange, considerWhitespaceChanges);
+        const diffResult = slice1.length + slice2.length < 500
+            ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout)
+            : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);
+        const check = false;
+        let diffs = diffResult.diffs;
+        if (check) {
+            diffAlgorithm_1.SequenceDiff.assertSorted(diffs);
+        }
+        diffs = (0, heuristicSequenceOptimizations_1.optimizeSequenceDiffs)(slice1, slice2, diffs);
+        if (check) {
+            diffAlgorithm_1.SequenceDiff.assertSorted(diffs);
+        }
+        diffs = (0, heuristicSequenceOptimizations_1.extendDiffsToEntireWordIfAppropriate)(slice1, slice2, diffs, (seq, idx) => seq.findWordContaining(idx));
+        if (check) {
+            diffAlgorithm_1.SequenceDiff.assertSorted(diffs);
+        }
+        if (options.extendToSubwords) {
+            diffs = (0, heuristicSequenceOptimizations_1.extendDiffsToEntireWordIfAppropriate)(slice1, slice2, diffs, (seq, idx) => seq.findSubWordContaining(idx), true);
+            if (check) {
+                diffAlgorithm_1.SequenceDiff.assertSorted(diffs);
+            }
+        }
+        diffs = (0, heuristicSequenceOptimizations_1.removeShortMatches)(slice1, slice2, diffs);
+        if (check) {
+            diffAlgorithm_1.SequenceDiff.assertSorted(diffs);
+        }
+        diffs = (0, heuristicSequenceOptimizations_1.removeVeryShortMatchingTextBetweenLongDiffs)(slice1, slice2, diffs);
+        if (check) {
+            diffAlgorithm_1.SequenceDiff.assertSorted(diffs);
+        }
+        const result = diffs.map((d) => new rangeMapping_1.RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)));
+        if (check) {
+            rangeMapping_1.RangeMapping.assertSorted(result);
+        }
+        // Assert: result applied on original should be the same as diff applied to original
+        return {
+            mappings: result,
+            hitTimeout: diffResult.hitTimeout,
+        };
+    }
+}
+exports.DefaultLinesDiffComputer = DefaultLinesDiffComputer;
+function toLineRangeMapping(sequenceDiff) {
+    return new rangeMapping_1.LineRangeMapping(new lineRange_1.LineRange(sequenceDiff.seq1Range.start + 1, sequenceDiff.seq1Range.endExclusive + 1), new lineRange_1.LineRange(sequenceDiff.seq2Range.start + 1, sequenceDiff.seq2Range.endExclusive + 1));
+}
+//# sourceMappingURL=defaultLinesDiffComputer.js.map

package/dist/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultLinesDiffComputer.js","sourceRoot":"","sources":["../../../../../../../../../src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.ts"],"names":[],"mappings":";AAAA,iEAAiE;;;AAEjE;;;gGAGgG;AAEhG,2DAAwD;AACxD,2DAA0D;AAC1D,2DAAwD;AACxD,+DAA4D;AAE5D,4CAAyC;AACzC,+DAAyD;AACzD,4DAA2G;AAC3G,kDAA8H;AAC9H,8DAAkG;AAClG,sFAAmF;AACnF,wEAAqE;AACrE,2DAAwD;AACxD,qFAA0N;AAC1N,iDAA8C;AAC9C,qEAAkE;AAElE,MAAa,wBAAwB;IAArC;QACkB,8BAAyB,GAAG,IAAI,qDAAyB,EAAE,CAAC;QAC5D,0BAAqB,GAAG,IAAI,uCAAkB,EAAE,CAAC;IA+OnE,CAAC;IA7OA,WAAW,CAAC,aAAuB,EAAE,aAAuB,EAAE,OAAkC;QAC/F,IAAI,aAAa,CAAC,MAAM,IAAI,CAAC,IAAI,IAAA,eAAM,EAAC,aAAa,EAAE,aAAa,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YAC1F,OAAO,IAAI,6BAAS,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChI,OAAO,IAAI,6BAAS,CAAC;gBACpB,IAAI,uCAAwB,CAC3B,IAAI,qBAAS,CAAC,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,EAC1C,IAAI,qBAAS,CAAC,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,EAC1C;oBACC,IAAI,2BAAY,CACf,IAAI,aAAK,CAAC,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EACzF,IAAI,aAAK,CAAC,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CACzF;iBACD,CACD;aACD,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAAG,OAAO,CAAC,oBAAoB,KAAK,CAAC,CAAC,CAAC,CAAC,+BAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,2BAAW,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;QAC9H,MAAM,yBAAyB,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC;QAEhE,MAAM,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;QAChD,SAAS,eAAe,CAAC,IAAY;YACpC,IAAI,IAAI,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACnC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACxB,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC;gBAC1B,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAC/B,CAAC;YACD,OAAO,IAAI,CAAC;QACb,CAAC;QAED,MAAM,mBAAmB,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAChF,MAAM,mBAAmB,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAEhF,MAAM,SAAS,GAAG,IAAI,2BAAY,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC;QACvE,MAAM,SAAS,GAAG,IAAI,2BAAY,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC;QAEvE,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE;YACjC,IAAI,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;gBAChD,6CAA6C;gBAC7C,OAAO,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAC5C,SAAS,EACT,SAAS,EACT,OAAO,EACP,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CACpB,aAAa,CAAC,OAAO,CAAC,KAAK,aAAa,CAAC,OAAO,CAAC;oBAChD,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC;wBACpC,CAAC,CAAC,GAAG;wBACL,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;oBAClD,CAAC,CAAC,IAAI,CACR,CAAC;YACH,CAAC;YAED,OAAO,IAAI,CAAC,qBAAqB,CAAC,OAAO,CACxC,SAAS,EACT,SAAS,EACT,OAAO,CACP,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QAEL,IAAI,cAAc,GAAG,mBAAmB,CAAC,KAAK,CAAC;QAC/C,IAAI,UAAU,GAAG,mBAAmB,CAAC,UAAU,CAAC;QAChD,cAAc,GAAG,IAAA,sDAAqB,EAAC,SAAS,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAC7E,cAAc,GAAG,IAAA,yEAAwC,EAAC,SAAS,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAEhG,MAAM,UAAU,GAAmB,EAAE,CAAC;QAEtC,MAAM,wBAAwB,GAAG,CAAC,eAAuB,EAAE,EAAE;YAC5D,IAAI,CAAC,yBAAyB,EAAE,CAAC;gBAChC,OAAO;YACR,CAAC;YAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC1C,MAAM,UAAU,GAAG,aAAa,GAAG,CAAC,CAAC;gBACrC,MAAM,UAAU,GAAG,aAAa,GAAG,CAAC,CAAC;gBACrC,IAAI,aAAa,CAAC,UAAU,CAAC,KAAK,aAAa,CAAC,UAAU,CAAC,EAAE,CAAC;oBAC7D,0DAA0D;oBAC1D,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,IAAI,4BAAY,CACpF,IAAI,yBAAW,CAAC,UAAU,EAAE,UAAU,GAAG,CAAC,CAAC,EAC3C,IAAI,yBAAW,CAAC,UAAU,EAAE,UAAU,GAAG,CAAC,CAAC,CAC3C,EAAE,OAAO,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;oBAChD,KAAK,MAAM,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,CAAC;wBACzC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBACpB,CAAC;oBACD,IAAI,cAAc,CAAC,UAAU,EAAE,CAAC;wBAC/B,UAAU,GAAG,IAAI,CAAC;oBACnB,CAAC;gBACF,CAAC;YACF,CAAC;QACF,CAAC,CAAC;QAEF,IAAI,aAAa,GAAG,CAAC,CAAC;QACtB,IAAI,aAAa,GAAG,CAAC,CAAC;QAEtB,KAAK,MAAM,IAAI,IAAI,cAAc,EAAE,CAAC;YACnC,IAAA,iBAAQ,EAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,aAAa,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,aAAa,CAAC,CAAC;YAE9F,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,aAAa,CAAC;YAE7D,wBAAwB,CAAC,eAAe,CAAC,CAAC;YAE1C,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;YAC5C,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;YAE5C,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;YACxH,IAAI,cAAc,CAAC,UAAU,EAAE,CAAC;gBAC/B,UAAU,GAAG,IAAI,CAAC;YACnB,CAAC;YACD,KAAK,MAAM,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,CAAC;gBACzC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,CAAC;QACF,CAAC;QAED,wBAAwB,CAAC,aAAa,CAAC,MAAM,GAAG,aAAa,CAAC,CAAC;QAE/D,MAAM,QAAQ,GAAG,IAAI,wBAAS,CAAC,aAAa,CAAC,CAAC;QAC9C,MAAM,QAAQ,GAAG,IAAI,wBAAS,CAAC,aAAa,CAAC,CAAC;QAE9C,MAAM,OAAO,GAAG,IAAA,gDAAiC,EAAC,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAElF,IAAI,KAAK,GAAgB,EAAE,CAAC;QAC5B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;YAC1B,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,OAAO,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;QACzJ,CAAC;QAED,iCAAiC;QACjC,IAAA,iBAAQ,EAAC,GAAG,EAAE;YACb,SAAS,gBAAgB,CAAC,GAAa,EAAE,KAAe;gBACvD,IAAI,GAAG,CAAC,UAAU,GAAG,CAAC,IAAI,GAAG,CAAC,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;oBAAC,OAAO,KAAK,CAAC;gBAAC,CAAC;gBAC1E,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;gBACvC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAAC,OAAO,KAAK,CAAC;gBAAC,CAAC;gBACrE,OAAO,IAAI,CAAC;YACb,CAAC;YAED,SAAS,aAAa,CAAC,KAAgB,EAAE,KAAe;gBACvD,IAAI,KAAK,CAAC,eAAe,GAAG,CAAC,IAAI,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAAC,OAAO,KAAK,CAAC;gBAAC,CAAC;gBAC5F,IAAI,KAAK,CAAC,sBAAsB,GAAG,CAAC,IAAI,KAAK,CAAC,sBAAsB,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAAC,OAAO,KAAK,CAAC;gBAAC,CAAC;gBAC1G,OAAO,IAAI,CAAC;YACb,CAAC;YAED,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;gBACzB,IAAI,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC;oBAAC,OAAO,KAAK,CAAC;gBAAC,CAAC;gBACtC,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;oBACjC,MAAM,KAAK,GAAG,gBAAgB,CAAC,EAAE,CAAC,aAAa,CAAC,gBAAgB,EAAE,EAAE,aAAa,CAAC,IAAI,gBAAgB,CAAC,EAAE,CAAC,aAAa,CAAC,cAAc,EAAE,EAAE,aAAa,CAAC;wBACvJ,gBAAgB,CAAC,EAAE,CAAC,aAAa,CAAC,gBAAgB,EAAE,EAAE,aAAa,CAAC,IAAI,gBAAgB,CAAC,EAAE,CAAC,aAAa,CAAC,cAAc,EAAE,EAAE,aAAa,CAAC,CAAC;oBAC5I,IAAI,CAAC,KAAK,EAAE,CAAC;wBACZ,OAAO,KAAK,CAAC;oBACd,CAAC;gBACF,CAAC;gBACD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,EAAE,aAAa,CAAC,EAAE,CAAC;oBAC5F,OAAO,KAAK,CAAC;gBACd,CAAC;YACF,CAAC;YACD,OAAO,IAAI,CAAC;QACb,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,6BAAS,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;IAClD,CAAC;IAEO,YAAY,CACnB,OAAmC,EACnC,aAAuB,EACvB,aAAuB,EACvB,mBAA6B,EAC7B,mBAA6B,EAC7B,OAAiB,EACjB,yBAAkC,EAClC,OAAkC;QAElC,MAAM,KAAK,GAAG,IAAA,qCAAiB,EAC9B,OAAO,EACP,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,mBAAmB,EACnB,OAAO,CACP,CAAC;QACF,MAAM,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YACpC,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,IAAI,4BAAY,CACjF,CAAC,CAAC,QAAQ,CAAC,aAAa,EAAE,EAC1B,CAAC,CAAC,QAAQ,CAAC,aAAa,EAAE,CAC1B,EAAE,OAAO,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;YAChD,MAAM,QAAQ,GAAG,IAAA,gDAAiC,EAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,wBAAS,CAAC,aAAa,CAAC,EAAE,IAAI,wBAAS,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC,CAAC;YAC3I,OAAO,IAAI,6BAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,OAAO,cAAc,CAAC;IACvB,CAAC;IAEO,UAAU,CAAC,aAAuB,EAAE,aAAuB,EAAE,IAAkB,EAAE,OAAiB,EAAE,yBAAkC,EAAE,OAAkC;QACjL,MAAM,gBAAgB,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAClD,MAAM,YAAY,GAAG,gBAAgB,CAAC,eAAe,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QAEpF,MAAM,MAAM,GAAG,IAAI,+CAAsB,CAAC,aAAa,EAAE,YAAY,CAAC,aAAa,EAAE,yBAAyB,CAAC,CAAC;QAChH,MAAM,MAAM,GAAG,IAAI,+CAAsB,CAAC,aAAa,EAAE,YAAY,CAAC,aAAa,EAAE,yBAAyB,CAAC,CAAC;QAEhH,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,GAAG;YACrD,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;YACjE,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAE/D,MAAM,KAAK,GAAG,KAAK,CAAC;QAEpB,IAAI,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC7B,IAAI,KAAK,EAAE,CAAC;YAAC,4BAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAAC,CAAC;QAChD,KAAK,GAAG,IAAA,sDAAqB,EAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QACrD,IAAI,KAAK,EAAE,CAAC;YAAC,4BAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAAC,CAAC;QAChD,KAAK,GAAG,IAAA,qEAAoC,EAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/G,IAAI,KAAK,EAAE,CAAC;YAAC,4BAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAAC,CAAC;QAEhD,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAC9B,KAAK,GAAG,IAAA,qEAAoC,EAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,qBAAqB,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;YACxH,IAAI,KAAK,EAAE,CAAC;gBAAC,4BAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAAC,CAAC;QACjD,CAAC;QAED,KAAK,GAAG,IAAA,mDAAkB,EAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QAClD,IAAI,KAAK,EAAE,CAAC;YAAC,4BAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAAC,CAAC;QAChD,KAAK,GAAG,IAAA,4EAA2C,EAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QAC3E,IAAI,KAAK,EAAE,CAAC;YAAC,4BAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAAC,CAAC;QAEhD,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CACvB,CAAC,CAAC,EAAE,EAAE,CACL,IAAI,2BAAY,CACf,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,EAClC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAClC,CACF,CAAC;QAEF,IAAI,KAAK,EAAE,CAAC;YAAC,2BAAY,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAAC,CAAC;QAEjD,oFAAoF;QAEpF,OAAO;YACN,QAAQ,EAAE,MAAM;YAChB,UAAU,EAAE,UAAU,CAAC,UAAU;SACjC,CAAC;IACH,CAAC;CACD;AAjPD,4DAiPC;AAED,SAAS,kBAAkB,CAAC,YAA0B;IACrD,OAAO,IAAI,+BAAgB,CAC1B,IAAI,qBAAS,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,GAAG,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,YAAY,GAAG,CAAC,CAAC,EACxF,IAAI,qBAAS,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,GAAG,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,YAAY,GAAG,CAAC,CAAC,CACxF,CAAC;AACH,CAAC"}

package/dist/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.d.ts

@@ -0,0 +1,10 @@
+import { OffsetRange } from '../../core/ranges/offsetRange';
+import { ISequence, SequenceDiff } from './algorithms/diffAlgorithm';
+import { LineSequence } from './lineSequence';
+import { LinesSliceCharSequence } from './linesSliceCharSequence';
+export declare function optimizeSequenceDiffs(sequence1: ISequence, sequence2: ISequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
+export declare function removeShortMatches(sequence1: ISequence, sequence2: ISequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
+export declare function extendDiffsToEntireWordIfAppropriate(sequence1: LinesSliceCharSequence, sequence2: LinesSliceCharSequence, sequenceDiffs: SequenceDiff[], findParent: (seq: LinesSliceCharSequence, idx: number) => OffsetRange | undefined, force?: boolean): SequenceDiff[];
+export declare function removeVeryShortMatchingLinesBetweenDiffs(sequence1: LineSequence, _sequence2: LineSequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
+export declare function removeVeryShortMatchingTextBetweenLongDiffs(sequence1: LinesSliceCharSequence, sequence2: LinesSliceCharSequence, sequenceDiffs: SequenceDiff[]): SequenceDiff[];
+//# sourceMappingURL=heuristicSequenceOptimizations.d.ts.map

package/dist/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heuristicSequenceOptimizations.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAc,YAAY,EAAE,MAAM,4BAA4B,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAQ/H;AAuLD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAiB5H;AAED,wBAAgB,oCAAoC,CACnD,SAAS,EAAE,sBAAsB,EACjC,SAAS,EAAE,sBAAsB,EACjC,aAAa,EAAE,YAAY,EAAE,EAC7B,UAAU,EAAE,CAAC,GAAG,EAAE,sBAAsB,EAAE,GAAG,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,EACjF,KAAK,GAAE,OAAe,GACpB,YAAY,EAAE,CAuEhB;AA0BD,wBAAgB,wCAAwC,CAAC,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CA6CzJ;AAED,wBAAgB,2CAA2C,CAAC,SAAS,EAAE,sBAAsB,EAAE,SAAS,EAAE,sBAAsB,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAqG/K"}

package/dist/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js

@@ -0,0 +1,380 @@
+"use strict";
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeSequenceDiffs = optimizeSequenceDiffs;
+exports.removeShortMatches = removeShortMatches;
+exports.extendDiffsToEntireWordIfAppropriate = extendDiffsToEntireWordIfAppropriate;
+exports.removeVeryShortMatchingLinesBetweenDiffs = removeVeryShortMatchingLinesBetweenDiffs;
+exports.removeVeryShortMatchingTextBetweenLongDiffs = removeVeryShortMatchingTextBetweenLongDiffs;
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const arrays_1 = require("../../../../base/common/arrays");
+const offsetRange_1 = require("../../core/ranges/offsetRange");
+const diffAlgorithm_1 = require("./algorithms/diffAlgorithm");
+function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
+    let result = sequenceDiffs;
+    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);
+    // Sometimes, calling this function twice improves the result.
+    // Uncomment the second invocation and run the tests to see the difference.
+    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);
+    result = shiftSequenceDiffs(sequence1, sequence2, result);
+    return result;
+}
+/**
+ * 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 joinSequenceDiffsByShifting(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.isStronglyEqual(cur.seq1Range.start + d, cur.seq1Range.endExclusive + d) ||
+                    !sequence2.isStronglyEqual(cur.seq2Range.start + d, 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;
+}
+// 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.endExclusive + 1 : 0, nextDiff ? nextDiff.seq1Range.start - 1 : sequence1.length);
+        const seq2ValidRange = new offsetRange_1.OffsetRange(prevDiff ? prevDiff.seq2Range.endExclusive + 1 : 0, nextDiff ? nextDiff.seq2Range.start - 1 : sequence2.length);
+        if (diff.seq1Range.isEmpty) {
+            sequenceDiffs[i] = shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange);
+        }
+        else if (diff.seq2Range.isEmpty) {
+            sequenceDiffs[i] = shiftDiffToBetterPosition(diff.swap(), sequence2, sequence1, seq2ValidRange, seq1ValidRange).swap();
+        }
+    }
+    return sequenceDiffs;
+}
+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);
+}
+function removeShortMatches(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;
+}
+function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs, findParent, force = false) {
+    const equalMappings = diffAlgorithm_1.SequenceDiff.invert(sequenceDiffs, sequence1.length);
+    const additional = [];
+    let lastPoint = new diffAlgorithm_1.OffsetPair(0, 0);
+    function scanWord(pair, equalMapping) {
+        if (pair.offset1 < lastPoint.offset1 || pair.offset2 < lastPoint.offset2) {
+            return;
+        }
+        const w1 = findParent(sequence1, pair.offset1);
+        const w2 = findParent(sequence2, pair.offset2);
+        if (!w1 || !w2) {
+            return;
+        }
+        let w = new diffAlgorithm_1.SequenceDiff(w1, w2);
+        const equalPart = w.intersect(equalMapping);
+        let equalChars1 = equalPart.seq1Range.length;
+        let equalChars2 = equalPart.seq2Range.length;
+        // The words do not touch previous equals mappings, as we would have processed them already.
+        // But they might touch the next ones.
+        while (equalMappings.length > 0) {
+            const next = equalMappings[0];
+            const intersects = next.seq1Range.intersects(w.seq1Range) || next.seq2Range.intersects(w.seq2Range);
+            if (!intersects) {
+                break;
+            }
+            const v1 = findParent(sequence1, next.seq1Range.start);
+            const v2 = findParent(sequence2, next.seq2Range.start);
+            // Because there is an intersection, we know that the words are not empty.
+            const v = new diffAlgorithm_1.SequenceDiff(v1, v2);
+            const equalPart = v.intersect(next);
+            equalChars1 += equalPart.seq1Range.length;
+            equalChars2 += equalPart.seq2Range.length;
+            w = w.join(v);
+            if (w.seq1Range.endExclusive >= next.seq1Range.endExclusive) {
+                // The word extends beyond the next equal mapping.
+                equalMappings.shift();
+            }
+            else {
+                break;
+            }
+        }
+        if ((force && equalChars1 + equalChars2 < w.seq1Range.length + w.seq2Range.length) || equalChars1 + equalChars2 < (w.seq1Range.length + w.seq2Range.length) * 2 / 3) {
+            additional.push(w);
+        }
+        lastPoint = w.getEndExclusives();
+    }
+    while (equalMappings.length > 0) {
+        const next = equalMappings.shift();
+        if (next.seq1Range.isEmpty) {
+            continue;
+        }
+        scanWord(next.getStarts(), next);
+        // The equal parts are not empty, so -1 gives us a character that is equal in both parts.
+        scanWord(next.getEndExclusives().delta(-1), next);
+    }
+    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 removeVeryShortMatchingLinesBetweenDiffs(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;
+}
+function removeVeryShortMatchingTextBetweenLongDiffs(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);
+    const newDiffs = [];
+    // Remove short suffixes/prefixes
+    (0, arrays_1.forEachWithNeighbors)(diffs, (prev, cur, next) => {
+        let newDiff = cur;
+        function shouldMarkAsChanged(text) {
+            return text.length > 0 && text.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100;
+        }
+        const fullRange1 = sequence1.extendToFullLines(cur.seq1Range);
+        const prefix = sequence1.getText(new offsetRange_1.OffsetRange(fullRange1.start, cur.seq1Range.start));
+        if (shouldMarkAsChanged(prefix)) {
+            newDiff = newDiff.deltaStart(-prefix.length);
+        }
+        const suffix = sequence1.getText(new offsetRange_1.OffsetRange(cur.seq1Range.endExclusive, fullRange1.endExclusive));
+        if (shouldMarkAsChanged(suffix)) {
+            newDiff = newDiff.deltaEnd(suffix.length);
+        }
+        const availableSpace = diffAlgorithm_1.SequenceDiff.fromOffsetPairs(prev ? prev.getEndExclusives() : diffAlgorithm_1.OffsetPair.zero, next ? next.getStarts() : diffAlgorithm_1.OffsetPair.max);
+        const result = newDiff.intersect(availableSpace);
+        if (newDiffs.length > 0 && result.getStarts().equals(newDiffs[newDiffs.length - 1].getEndExclusives())) {
+            newDiffs[newDiffs.length - 1] = newDiffs[newDiffs.length - 1].join(result);
+        }
+        else {
+            newDiffs.push(result);
+        }
+    });
+    return newDiffs;
+}
+//# sourceMappingURL=heuristicSequenceOptimizations.js.map