@vscode/chat-lib 0.0.1

package/src/_internal/util/vs/editor/common/diff/defaultLinesDiffComputer/computeMovedLines.ts

@@ -0,0 +1,331 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ITimeout, SequenceDiff } from './algorithms/diffAlgorithm';
+import { DetailedLineRangeMapping, LineRangeMapping } from '../rangeMapping';
+import { pushMany, compareBy, numberComparator, reverseOrder } from '../../../../base/common/arrays';
+import { MonotonousArray, findLastMonotonous } from '../../../../base/common/arraysFind';
+import { SetMap } from '../../../../base/common/map';
+import { LineRange, LineRangeSet } from '../../core/ranges/lineRange';
+import { LinesSliceCharSequence } from './linesSliceCharSequence';
+import { LineRangeFragment, isSpace } from './utils';
+import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm';
+import { Range } from '../../core/range';
+
+export function computeMovedLines(
+	changes: DetailedLineRangeMapping[],
+	originalLines: string[],
+	modifiedLines: string[],
+	hashedOriginalLines: number[],
+	hashedModifiedLines: number[],
+	timeout: ITimeout
+): LineRangeMapping[] {
+	let { moves, excludedChanges } = computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout);
+
+	if (!timeout.isValid()) { return []; }
+
+	const filteredChanges = changes.filter(c => !excludedChanges.has(c));
+	const unchangedMoves = computeUnchangedMoves(filteredChanges, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout);
+	pushMany(moves, unchangedMoves);
+
+	moves = joinCloseConsecutiveMoves(moves);
+	// Ignore too short moves
+	moves = moves.filter(current => {
+		const lines = current.original.toOffsetRange().slice(originalLines).map(l => l.trim());
+		const originalText = lines.join('\n');
+		return originalText.length >= 15 && countWhere(lines, l => l.length >= 2) >= 2;
+	});
+	moves = removeMovesInSameDiff(changes, moves);
+
+	return moves;
+}
+
+function countWhere<T>(arr: T[], predicate: (t: T) => boolean): number {
+	let count = 0;
+	for (const t of arr) {
+		if (predicate(t)) {
+			count++;
+		}
+	}
+	return count;
+}
+
+function computeMovesFromSimpleDeletionsToSimpleInsertions(
+	changes: DetailedLineRangeMapping[],
+	originalLines: string[],
+	modifiedLines: string[],
+	timeout: ITimeout,
+) {
+	const moves: LineRangeMapping[] = [];
+
+	const deletions = changes
+		.filter(c => c.modified.isEmpty && c.original.length >= 3)
+		.map(d => new LineRangeFragment(d.original, originalLines, d));
+	const insertions = new Set(changes
+		.filter(c => c.original.isEmpty && c.modified.length >= 3)
+		.map(d => new LineRangeFragment(d.modified, modifiedLines, d)));
+
+	const excludedChanges = new Set<DetailedLineRangeMapping>();
+
+	for (const deletion of deletions) {
+		let highestSimilarity = -1;
+		let best: LineRangeFragment | undefined;
+		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 LineRangeMapping(deletion.range, best.range));
+			excludedChanges.add(deletion.source);
+			excludedChanges.add(best.source);
+		}
+
+		if (!timeout.isValid()) {
+			return { moves, excludedChanges };
+		}
+	}
+
+	return { moves, excludedChanges };
+}
+
+function computeUnchangedMoves(
+	changes: DetailedLineRangeMapping[],
+	hashedOriginalLines: number[],
+	hashedModifiedLines: number[],
+	originalLines: string[],
+	modifiedLines: string[],
+	timeout: ITimeout,
+) {
+	const moves: LineRangeMapping[] = [];
+
+	const original3LineHashes = new SetMap<string, { range: LineRange }>();
+
+	for (const change of changes) {
+		for (let i = change.original.startLineNumber; i < change.original.endLineNumberExclusive - 2; i++) {
+			const key = `${hashedOriginalLines[i - 1]}:${hashedOriginalLines[i + 1 - 1]}:${hashedOriginalLines[i + 2 - 1]}`;
+			original3LineHashes.add(key, { range: new LineRange(i, i + 3) });
+		}
+	}
+
+	interface PossibleMapping {
+		modifiedLineRange: LineRange;
+		originalLineRange: LineRange;
+	}
+
+	const possibleMappings: PossibleMapping[] = [];
+
+	changes.sort(compareBy(c => c.modified.startLineNumber, numberComparator));
+
+	for (const change of changes) {
+		let lastMappings: PossibleMapping[] = [];
+		for (let i = change.modified.startLineNumber; i < change.modified.endLineNumberExclusive - 2; i++) {
+			const key = `${hashedModifiedLines[i - 1]}:${hashedModifiedLines[i + 1 - 1]}:${hashedModifiedLines[i + 2 - 1]}`;
+			const currentModifiedRange = new LineRange(i, i + 3);
+
+			const nextMappings: PossibleMapping[] = [];
+			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(lastMapping.originalLineRange.startLineNumber, range.endLineNumberExclusive);
+						lastMapping.modifiedLineRange = new LineRange(lastMapping.modifiedLineRange.startLineNumber, currentModifiedRange.endLineNumberExclusive);
+						nextMappings.push(lastMapping);
+						return;
+					}
+				}
+
+				const mapping: PossibleMapping = {
+					modifiedLineRange: currentModifiedRange,
+					originalLineRange: range,
+				};
+				possibleMappings.push(mapping);
+				nextMappings.push(mapping);
+			});
+			lastMappings = nextMappings;
+		}
+
+		if (!timeout.isValid()) {
+			return [];
+		}
+	}
+
+	possibleMappings.sort(reverseOrder(compareBy(m => m.modifiedLineRange.length, 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).getWithDelta(diffOrigToMod);
+
+		const modifiedIntersectedSections = modifiedSections.getIntersection(originalTranslatedSections);
+
+		for (const s of modifiedIntersectedSections.ranges) {
+			if (s.length < 3) {
+				continue;
+			}
+			const modifiedLineRange = s;
+			const originalLineRange = s.delta(-diffOrigToMod);
+
+			moves.push(new LineRangeMapping(originalLineRange, modifiedLineRange));
+
+			modifiedSet.addRange(modifiedLineRange);
+			originalSet.addRange(originalLineRange);
+		}
+	}
+
+	moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));
+
+	const monotonousChanges = new MonotonousArray(changes);
+	for (let i = 0; i < moves.length; i++) {
+		const move = moves[i];
+		const firstTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber <= move.original.startLineNumber)!;
+		const firstTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber <= move.modified.startLineNumber)!;
+		const linesAbove = Math.max(
+			move.original.startLineNumber - firstTouchingChangeOrig.original.startLineNumber,
+			move.modified.startLineNumber - firstTouchingChangeMod.modified.startLineNumber
+		);
+
+		const lastTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber < move.original.endLineNumberExclusive)!;
+		const lastTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber < move.modified.endLineNumberExclusive)!;
+		const linesBelow = Math.max(
+			lastTouchingChangeOrig.original.endLineNumberExclusive - move.original.endLineNumberExclusive,
+			lastTouchingChangeMod.modified.endLineNumberExclusive - move.modified.endLineNumberExclusive
+		);
+
+		let extendToTop: number;
+		for (extendToTop = 0; extendToTop < linesAbove; extendToTop++) {
+			const origLine = move.original.startLineNumber - extendToTop - 1;
+			const modLine = move.modified.startLineNumber - extendToTop - 1;
+			if (origLine > originalLines.length || modLine > modifiedLines.length) {
+				break;
+			}
+			if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {
+				break;
+			}
+			if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {
+				break;
+			}
+		}
+
+		if (extendToTop > 0) {
+			originalSet.addRange(new LineRange(move.original.startLineNumber - extendToTop, move.original.startLineNumber));
+			modifiedSet.addRange(new LineRange(move.modified.startLineNumber - extendToTop, move.modified.startLineNumber));
+		}
+
+		let extendToBottom: number;
+		for (extendToBottom = 0; extendToBottom < linesBelow; extendToBottom++) {
+			const origLine = move.original.endLineNumberExclusive + extendToBottom;
+			const modLine = move.modified.endLineNumberExclusive + extendToBottom;
+			if (origLine > originalLines.length || modLine > modifiedLines.length) {
+				break;
+			}
+			if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {
+				break;
+			}
+			if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {
+				break;
+			}
+		}
+
+		if (extendToBottom > 0) {
+			originalSet.addRange(new LineRange(move.original.endLineNumberExclusive, move.original.endLineNumberExclusive + extendToBottom));
+			modifiedSet.addRange(new LineRange(move.modified.endLineNumberExclusive, move.modified.endLineNumberExclusive + extendToBottom));
+		}
+
+		if (extendToTop > 0 || extendToBottom > 0) {
+			moves[i] = new LineRangeMapping(
+				new LineRange(move.original.startLineNumber - extendToTop, move.original.endLineNumberExclusive + extendToBottom),
+				new LineRange(move.modified.startLineNumber - extendToTop, move.modified.endLineNumberExclusive + extendToBottom),
+			);
+		}
+	}
+
+	return moves;
+}
+
+function areLinesSimilar(line1: string, line2: string, timeout: ITimeout): boolean {
+	if (line1.trim() === line2.trim()) { return true; }
+	if (line1.length > 300 && line2.length > 300) { return false; }
+
+	const myersDiffingAlgorithm = new MyersDiffAlgorithm();
+	const result = myersDiffingAlgorithm.compute(
+		new LinesSliceCharSequence([line1], new Range(1, 1, 1, line1.length), false),
+		new LinesSliceCharSequence([line2], new Range(1, 1, 1, line2.length), false),
+		timeout
+	);
+	let commonNonSpaceCharCount = 0;
+	const inverted = SequenceDiff.invert(result.diffs, line1.length);
+	for (const seq of inverted) {
+		seq.seq1Range.forEach(idx => {
+			if (!isSpace(line1.charCodeAt(idx))) {
+				commonNonSpaceCharCount++;
+			}
+		});
+	}
+
+	function countNonWsChars(str: string): number {
+		let count = 0;
+		for (let i = 0; i < line1.length; i++) {
+			if (!isSpace(str.charCodeAt(i))) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	const longerLineLength = countNonWsChars(line1.length > line2.length ? line1 : line2);
+	const r = commonNonSpaceCharCount / longerLineLength > 0.6 && longerLineLength > 10;
+	return r;
+}
+
+function joinCloseConsecutiveMoves(moves: LineRangeMapping[]): LineRangeMapping[] {
+	if (moves.length === 0) {
+		return moves;
+	}
+
+	moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));
+
+	const result = [moves[0]];
+	for (let i = 1; i < moves.length; i++) {
+		const last = result[result.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) {
+			result[result.length - 1] = last.join(current);
+			continue;
+		}
+
+		result.push(current);
+	}
+	return result;
+}
+
+function removeMovesInSameDiff(changes: DetailedLineRangeMapping[], moves: LineRangeMapping[]) {
+	const changesMonotonous = new MonotonousArray(changes);
+	moves = moves.filter(m => {
+		const diffBeforeEndOfMoveOriginal = changesMonotonous.findLastMonotonous(c => c.original.startLineNumber < m.original.endLineNumberExclusive)
+			|| new LineRangeMapping(new LineRange(1, 1), new LineRange(1, 1));
+		const diffBeforeEndOfMoveModified = findLastMonotonous(changes, c => c.modified.startLineNumber < m.modified.endLineNumberExclusive);
+
+		const differentDiffs = diffBeforeEndOfMoveOriginal !== diffBeforeEndOfMoveModified;
+		return differentDiffs;
+	});
+	return moves;
+}

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

@@ -0,0 +1,273 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { equals } from '../../../../base/common/arrays';
+import { assertFn } from '../../../../base/common/assert';
+import { LineRange } from '../../core/ranges/lineRange';
+import { OffsetRange } from '../../core/ranges/offsetRange';
+import { Position } from '../../core/position';
+import { Range } from '../../core/range';
+import { ArrayText } from '../../core/text/abstractText';
+import { ILinesDiffComputer, ILinesDiffComputerOptions, LinesDiff, MovedText } from '../linesDiffComputer';
+import { DetailedLineRangeMapping, LineRangeMapping, lineRangeMappingFromRangeMappings, RangeMapping } from '../rangeMapping';
+import { DateTimeout, InfiniteTimeout, ITimeout, SequenceDiff } from './algorithms/diffAlgorithm';
+import { DynamicProgrammingDiffing } from './algorithms/dynamicProgrammingDiffing';
+import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm';
+import { computeMovedLines } from './computeMovedLines';
+import { extendDiffsToEntireWordIfAppropriate, optimizeSequenceDiffs, removeShortMatches, removeVeryShortMatchingLinesBetweenDiffs, removeVeryShortMatchingTextBetweenLongDiffs } from './heuristicSequenceOptimizations';
+import { LineSequence } from './lineSequence';
+import { LinesSliceCharSequence } from './linesSliceCharSequence';
+
+export class DefaultLinesDiffComputer implements ILinesDiffComputer {
+	private readonly dynamicProgrammingDiffing = new DynamicProgrammingDiffing();
+	private readonly myersDiffingAlgorithm = new MyersDiffAlgorithm();
+
+	computeDiff(originalLines: string[], modifiedLines: string[], options: ILinesDiffComputerOptions): LinesDiff {
+		if (originalLines.length <= 1 && equals(originalLines, modifiedLines, (a, b) => a === b)) {
+			return new LinesDiff([], [], false);
+		}
+
+		if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {
+			return new LinesDiff([
+				new DetailedLineRangeMapping(
+					new LineRange(1, originalLines.length + 1),
+					new LineRange(1, modifiedLines.length + 1),
+					[
+						new RangeMapping(
+							new Range(1, 1, originalLines.length, originalLines[originalLines.length - 1].length + 1),
+							new Range(1, 1, modifiedLines.length, modifiedLines[modifiedLines.length - 1].length + 1),
+						)
+					]
+				)
+			], [], false);
+		}
+
+		const timeout = options.maxComputationTimeMs === 0 ? InfiniteTimeout.instance : new DateTimeout(options.maxComputationTimeMs);
+		const considerWhitespaceChanges = !options.ignoreTrimWhitespace;
+
+		const perfectHashes = new Map<string, number>();
+		function getOrCreateHash(text: string): number {
+			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(originalLinesHashes, originalLines);
+		const sequence2 = new 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 = optimizeSequenceDiffs(sequence1, sequence2, lineAlignments);
+		lineAlignments = removeVeryShortMatchingLinesBetweenDiffs(sequence1, sequence2, lineAlignments);
+
+		const alignments: RangeMapping[] = [];
+
+		const scanForWhitespaceChanges = (equalLinesCount: number) => {
+			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 SequenceDiff(
+						new OffsetRange(seq1Offset, seq1Offset + 1),
+						new 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) {
+			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 ArrayText(originalLines);
+		const modified = new ArrayText(modifiedLines);
+
+		const changes = lineRangeMappingFromRangeMappings(alignments, original, modified);
+
+		let moves: MovedText[] = [];
+		if (options.computeMoves) {
+			moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges, options);
+		}
+
+		// Make sure all ranges are valid
+		assertFn(() => {
+			function validatePosition(pos: Position, lines: string[]): boolean {
+				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: LineRange, lines: string[]): boolean {
+				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 LinesDiff(changes, moves, hitTimeout);
+	}
+
+	private computeMoves(
+		changes: DetailedLineRangeMapping[],
+		originalLines: string[],
+		modifiedLines: string[],
+		hashedOriginalLines: number[],
+		hashedModifiedLines: number[],
+		timeout: ITimeout,
+		considerWhitespaceChanges: boolean,
+		options: ILinesDiffComputerOptions,
+	): MovedText[] {
+		const moves = computeMovedLines(
+			changes,
+			originalLines,
+			modifiedLines,
+			hashedOriginalLines,
+			hashedModifiedLines,
+			timeout,
+		);
+		const movesWithDiffs = moves.map(m => {
+			const moveChanges = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(
+				m.original.toOffsetRange(),
+				m.modified.toOffsetRange(),
+			), timeout, considerWhitespaceChanges, options);
+			const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, new ArrayText(originalLines), new ArrayText(modifiedLines), true);
+			return new MovedText(m, mappings);
+		});
+		return movesWithDiffs;
+	}
+
+	private refineDiff(originalLines: string[], modifiedLines: string[], diff: SequenceDiff, timeout: ITimeout, considerWhitespaceChanges: boolean, options: ILinesDiffComputerOptions): { mappings: RangeMapping[]; hitTimeout: boolean } {
+		const lineRangeMapping = toLineRangeMapping(diff);
+		const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
+
+		const slice1 = new LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges);
+		const slice2 = new 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) { SequenceDiff.assertSorted(diffs); }
+		diffs = optimizeSequenceDiffs(slice1, slice2, diffs);
+		if (check) { SequenceDiff.assertSorted(diffs); }
+		diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findWordContaining(idx));
+		if (check) { SequenceDiff.assertSorted(diffs); }
+
+		if (options.extendToSubwords) {
+			diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findSubWordContaining(idx), true);
+			if (check) { SequenceDiff.assertSorted(diffs); }
+		}
+
+		diffs = removeShortMatches(slice1, slice2, diffs);
+		if (check) { SequenceDiff.assertSorted(diffs); }
+		diffs = removeVeryShortMatchingTextBetweenLongDiffs(slice1, slice2, diffs);
+		if (check) { SequenceDiff.assertSorted(diffs); }
+
+		const result = diffs.map(
+			(d) =>
+				new RangeMapping(
+					slice1.translateRange(d.seq1Range),
+					slice2.translateRange(d.seq2Range)
+				)
+		);
+
+		if (check) { RangeMapping.assertSorted(result); }
+
+		// Assert: result applied on original should be the same as diff applied to original
+
+		return {
+			mappings: result,
+			hitTimeout: diffResult.hitTimeout,
+		};
+	}
+}
+
+function toLineRangeMapping(sequenceDiff: SequenceDiff) {
+	return new LineRangeMapping(
+		new LineRange(sequenceDiff.seq1Range.start + 1, sequenceDiff.seq1Range.endExclusive + 1),
+		new LineRange(sequenceDiff.seq2Range.start + 1, sequenceDiff.seq2Range.endExclusive + 1),
+	);
+}