@vscode/chat-lib 0.0.1 → 0.0.2

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

@@ -1,331 +0,0 @@
-//!!! 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

@@ -1,273 +0,0 @@
-//!!! 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),
-	);
-}