@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js

@@ -0,0 +1,329 @@
+import { forEachWithNeighbors } from '../../../../base/common/arrays.js';
+import { OffsetRange } from '../../core/offsetRange.js';
+import { SequenceDiff, OffsetPair } from './algorithms/diffAlgorithm.js';
+function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
+    let result = sequenceDiffs;
+    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);
+    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);
+    result = shiftSequenceDiffs(sequence1, sequence2, result);
+    return result;
+}
+function joinSequenceDiffsByShifting(sequence1, sequence2, sequenceDiffs) {
+    if (sequenceDiffs.length === 0) {
+        return sequenceDiffs;
+    }
+    const result = [];
+    result.push(sequenceDiffs[0]);
+    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) {
+                result[result.length - 1] = ( new SequenceDiff(( new OffsetRange(prevResult.seq1Range.start, cur.seq1Range.endExclusive - length)), ( new OffsetRange(prevResult.seq2Range.start, cur.seq2Range.endExclusive - length))));
+                continue;
+            }
+            cur = cur.delta(-d);
+        }
+        result.push(cur);
+    }
+    const result2 = [];
+    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) {
+                result[i + 1] = ( new SequenceDiff(( new OffsetRange(cur.seq1Range.start + length, nextResult.seq1Range.endExclusive)), ( new 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;
+}
+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(
+            prevDiff ? prevDiff.seq1Range.start + 1 : 0,
+            nextDiff ? nextDiff.seq1Range.endExclusive - 1 : sequence1.length
+        ));
+        const seq2ValidRange = ( new 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.swap(), sequence2, sequence1, seq2ValidRange, seq1ValidRange).swap();
+        }
+    }
+    return sequenceDiffs;
+}
+function shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange) {
+    const maxShiftLimit = 100;
+    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;
+    }
+    let bestDelta = 0;
+    let bestScore = -1;
+    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 SequenceDiff(last.seq1Range.join(s.seq1Range), last.seq2Range.join(s.seq2Range)));
+        }
+        else {
+            result.push(s);
+        }
+    }
+    return result;
+}
+function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs) {
+    const additional = [];
+    let lastModifiedWord = undefined;
+    function maybePushWordToAdditional() {
+        if (!lastModifiedWord) {
+            return;
+        }
+        const originalLength1 = lastModifiedWord.s1Range.length - lastModifiedWord.deleted;
+        if (Math.max(lastModifiedWord.deleted, lastModifiedWord.added) + (lastModifiedWord.count - 1) > originalLength1) {
+            additional.push(( new 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.tryCreate(lastModifiedWord.s1Range.endExclusive, s1Range.start);
+                    const s2Added = 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 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(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(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;
+                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 = [];
+    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(fullRange1.start, cur.seq1Range.start)));
+        if (shouldMarkAsChanged(prefix)) {
+            newDiff = newDiff.deltaStart(-prefix.length);
+        }
+        const suffix = sequence1.getText(( new OffsetRange(cur.seq1Range.endExclusive, fullRange1.endExclusive)));
+        if (shouldMarkAsChanged(suffix)) {
+            newDiff = newDiff.deltaEnd(suffix.length);
+        }
+        const availableSpace = SequenceDiff.fromOffsetPairs(prev ? prev.getEndExclusives() : OffsetPair.zero, next ? next.getStarts() : OffsetPair.max);
+        const result = newDiff.intersect(availableSpace);
+        newDiffs.push(result);
+    });
+    return newDiffs;
+}
+export { extendDiffsToEntireWordIfAppropriate, optimizeSequenceDiffs, removeShortMatches, removeVeryShortMatchingLinesBetweenDiffs, removeVeryShortMatchingTextBetweenLongDiffs };

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/lineSequence.js

@@ -0,0 +1,31 @@
+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];
+    }
+}
+function getIndentation(str) {
+    let i = 0;
+    while (i < str.length && (str.charCodeAt(i) === 32  || str.charCodeAt(i) === 9 )) {
+        i++;
+    }
+    return i;
+}
+export { LineSequence };

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js

@@ -0,0 +1,166 @@
+import { findLastIdxMonotonous, findLastMonotonous, findFirstMonotonous } from '../../../../base/common/arraysFind.js';
+import { OffsetRange } from '../../core/offsetRange.js';
+import { Position } from '../../core/position.js';
+import { Range } from '../../core/range.js';
+import { isSpace } from './utils.js';
+class LinesSliceCharSequence {
+    constructor(lines, lineRange, considerWhitespaceChanges) {
+        this.lines = lines;
+        this.considerWhitespaceChanges = considerWhitespaceChanges;
+        this.elements = [];
+        this.firstCharOffsetByLine = [];
+        this.additionalOffsetByLine = [];
+        let trimFirstLineFully = false;
+        if (lineRange.start > 0 && lineRange.endExclusive >= lines.length) {
+            lineRange = ( new OffsetRange(lineRange.start - 1, lineRange.endExclusive));
+            trimFirstLineFully = true;
+        }
+        this.lineRange = lineRange;
+        this.firstCharOffsetByLine[0] = 0;
+        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));
+            }
+            if (i < lines.length - 1) {
+                this.elements.push('\n'.charCodeAt(0));
+                this.firstCharOffsetByLine[i - this.lineRange.start + 1] = this.elements.length;
+            }
+        }
+        this.additionalOffsetByLine.push(0);
+    }
+    toString() {
+        return `Slice: "${this.text}"`;
+    }
+    get text() {
+        return this.getText(( new 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) {
+        const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1);
+        const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1);
+        if (prevCategory === 7  && nextCategory === 8 ) {
+            return 0;
+        }
+        let score = 0;
+        if (prevCategory !== nextCategory) {
+            score += 10;
+            if (prevCategory === 0  && nextCategory === 1 ) {
+                score += 1;
+            }
+        }
+        score += getCategoryBoundaryScore(prevCategory);
+        score += getCategoryBoundaryScore(nextCategory);
+        return score;
+    }
+    translateOffset(offset) {
+        if (this.lineRange.isEmpty) {
+            return ( new Position(this.lineRange.start + 1, 1));
+        }
+        const i = findLastIdxMonotonous(this.firstCharOffsetByLine, (value) => value <= offset);
+        return ( new Position(
+            this.lineRange.start + i + 1,
+            offset - this.firstCharOffsetByLine[i] + this.additionalOffsetByLine[i] + 1
+        ));
+    }
+    translateRange(range) {
+        return Range.fromPositions(this.translateOffset(range.start), this.translateOffset(range.endExclusive));
+    }
+    findWordContaining(offset) {
+        if (offset < 0 || offset >= this.elements.length) {
+            return undefined;
+        }
+        if (!isWordChar(this.elements[offset])) {
+            return undefined;
+        }
+        let start = offset;
+        while (start > 0 && isWordChar(this.elements[start - 1])) {
+            start--;
+        }
+        let end = offset;
+        while (end < this.elements.length && isWordChar(this.elements[end])) {
+            end++;
+        }
+        return ( new 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.firstCharOffsetByLine, x => x <= range.start) ?? 0;
+        const end = findFirstMonotonous(this.firstCharOffsetByLine, x => range.endExclusive <= x) ?? this.elements.length;
+        return ( new OffsetRange(start, end));
+    }
+}
+function isWordChar(charCode) {
+    return charCode >= 97  && charCode <= 122
+        || charCode >= 65  && charCode <= 90
+        || charCode >= 48  && charCode <= 57 ;
+}
+const score = {
+    [0 ]: 0,
+    [1 ]: 0,
+    [2 ]: 0,
+    [3 ]: 10,
+    [4 ]: 2,
+    [5 ]: 3,
+    [6 ]: 3,
+    [7 ]: 10,
+    [8 ]: 10,
+};
+function getCategoryBoundaryScore(category) {
+    return score[category];
+}
+function getCategory(charCode) {
+    if (charCode === 10 ) {
+        return 8 ;
+    }
+    else if (charCode === 13 ) {
+        return 7 ;
+    }
+    else if (isSpace(charCode)) {
+        return 6 ;
+    }
+    else if (charCode >= 97  && charCode <= 122 ) {
+        return 0 ;
+    }
+    else if (charCode >= 65  && charCode <= 90 ) {
+        return 1 ;
+    }
+    else if (charCode >= 48  && charCode <= 57 ) {
+        return 2 ;
+    }
+    else if (charCode === -1) {
+        return 3 ;
+    }
+    else if (charCode === 44  || charCode === 59 ) {
+        return 5 ;
+    }
+    else {
+        return 4 ;
+    }
+}
+export { LinesSliceCharSequence };

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/utils.js

@@ -0,0 +1,57 @@
+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;
+    }
+}
+function isSpace(charCode) {
+    return charCode === 32  || charCode === 9 ;
+}
+class LineRangeFragment {
+    static { this.chrKeys = ( new Map()); }
+    static getKey(chr) {
+        let key = this.chrKeys.get(chr);
+        if (key === undefined) {
+            key = this.chrKeys.size;
+            this.chrKeys.set(chr, key);
+        }
+        return key;
+    }
+    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 = LineRangeFragment.getKey(chr);
+                this.histogram[key] = (this.histogram[key] || 0) + 1;
+            }
+            counter++;
+            const key = LineRangeFragment.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));
+    }
+}
+export { Array2D, LineRangeFragment, isSpace };

package/vscode/src/vs/editor/common/diff/documentDiffProvider.d.ts

@@ -1,5 +1,6 @@
 import { MovedText } from './linesDiffComputer.js';
 import { DetailedLineRangeMapping } from './rangeMapping.js';
+import '../../editor.api.js';
 
 /**
  * Options for the diff computation.