@pierre/diffs 1.1.2 → 1.1.4

package/dist/utils/parseMergeConflictDiffFromFile.js

@@ -1,131 +1,416 @@
-import { splitFileContents } from "./splitFileContents.js";
-import { processFile } from "./parsePatchFiles.js";
-import { getMergeConflictActionLineNumber, getMergeConflictParseResult } from "./getMergeConflictLineTypes.js";
-
 //#region src/utils/parseMergeConflictDiffFromFile.ts
-function getMergeConflictActionAnchor(action) {
-	if (action.incomingLineNumber != null) return {
-		side: "additions",
-		lineNumber: action.incomingLineNumber
-	};
-	if (action.currentLineNumber != null) return {
-		side: "deletions",
-		lineNumber: action.currentLineNumber
+function getMergeConflictActionAnchor(action, fileDiff) {
+	const hunk = fileDiff.hunks[action.hunkIndex];
+	if (hunk == null) return;
+	return {
+		hunkIndex: action.hunkIndex,
+		lineIndex: getUnifiedLineStartForContent(hunk, action.startContentIndex)
 	};
 }
-function parseMergeConflictDiffFromFile(file) {
-	const lines = splitFileContents(file.contents);
-	const { lineTypes, regions } = getMergeConflictParseResult(lines);
-	const currentContentChunks = [];
-	const incomingContentChunks = [];
-	const patchContentChunks = [];
-	const actions = new Array(regions.length);
-	const actionOriginalLineNumbersByRegion = new Array(regions.length);
-	const actionOriginalLineIndexesByRegion = new Array(regions.length);
-	const actionLineIndexSet = /* @__PURE__ */ new Set();
-	for (let regionIndex = 0; regionIndex < regions.length; regionIndex++) {
-		const actionOriginalLineNumber = getMergeConflictActionLineNumber(regions[regionIndex]);
-		const actionOriginalLineIndex = actionOriginalLineNumber - 1;
-		actionOriginalLineNumbersByRegion[regionIndex] = actionOriginalLineNumber;
-		actionOriginalLineIndexesByRegion[regionIndex] = actionOriginalLineIndex;
-		actionLineIndexSet.add(actionOriginalLineIndex);
-	}
-	const actionLineNumbersByOriginalIndex = /* @__PURE__ */ new Map();
-	let currentLineNumber = 0;
-	let incomingLineNumber = 0;
-	let actionIndex = 0;
-	let nextConflict = regions[actionIndex];
-	let nextActionOriginalLineNumber = nextConflict != null ? actionOriginalLineNumbersByRegion[actionIndex] : -1;
-	let nextActionOriginalLineIndex = nextConflict != null ? actionOriginalLineIndexesByRegion[actionIndex] : -1;
-	for (let index = 0; index < lines.length; index++) {
-		const line = lines[index];
-		const lineType = lineTypes[index];
-		let currentLineNumberAtIndex;
-		let incomingLineNumberAtIndex;
-		switch (lineType) {
-			case "none":
-				currentContentChunks.push(line);
-				incomingContentChunks.push(line);
-				patchContentChunks.push(` ${line}`);
-				currentLineNumber++;
-				incomingLineNumber++;
-				currentLineNumberAtIndex = currentLineNumber;
-				incomingLineNumberAtIndex = incomingLineNumber;
-				break;
-			case "current":
-				currentContentChunks.push(line);
-				patchContentChunks.push(`-${line}`);
-				currentLineNumber++;
-				currentLineNumberAtIndex = currentLineNumber;
-				break;
-			case "incoming":
-				incomingContentChunks.push(line);
-				patchContentChunks.push(`+${line}`);
-				incomingLineNumber++;
-				incomingLineNumberAtIndex = incomingLineNumber;
-				break;
-			case "base":
-			case "marker-start":
-			case "marker-base":
-			case "marker-separator":
-			case "marker-end":
-				currentContentChunks.push(line);
-				incomingContentChunks.push(line);
-				patchContentChunks.push(` ${line}`);
-				currentLineNumber++;
-				incomingLineNumber++;
-				currentLineNumberAtIndex = currentLineNumber;
-				incomingLineNumberAtIndex = incomingLineNumber;
-				break;
-			default: assertNever(lineType);
-		}
-		if (actionLineIndexSet.has(index)) actionLineNumbersByOriginalIndex.set(index, {
-			currentLineNumber: currentLineNumberAtIndex,
-			incomingLineNumber: incomingLineNumberAtIndex
-		});
-		while (nextConflict != null && nextActionOriginalLineIndex <= index) {
-			const actionLineNumbers = actionLineNumbersByOriginalIndex.get(nextActionOriginalLineIndex);
-			actions[actionIndex] = {
-				actionOriginalLineIndex: nextActionOriginalLineIndex,
-				actionOriginalLineNumber: nextActionOriginalLineNumber,
-				currentLineNumber: actionLineNumbers?.currentLineNumber,
-				incomingLineNumber: actionLineNumbers?.incomingLineNumber,
-				conflict: nextConflict,
-				conflictIndex: nextConflict.conflictIndex
-			};
-			actionIndex++;
-			nextConflict = regions[actionIndex];
-			if (nextConflict == null) break;
-			nextActionOriginalLineNumber = actionOriginalLineNumbersByRegion[actionIndex];
-			nextActionOriginalLineIndex = actionOriginalLineIndexesByRegion[actionIndex];
+function parseMergeConflictDiffFromFile(file, maxContextLines = 6) {
+	maxContextLines = Math.max(maxContextLines, 1);
+	const s = {
+		deletionLines: [],
+		additionLines: [],
+		conflictStack: [],
+		conflictBuilders: [],
+		actions: [],
+		hunks: [],
+		nextConflictIndex: 0,
+		splitLineCount: 0,
+		unifiedLineCount: 0,
+		lastHunkEnd: 0,
+		activeHunk: void 0,
+		maxContextLines,
+		maxContextLines2: maxContextLines * 2
+	};
+	const contents = file.contents;
+	const contentLength = contents.length;
+	if (contentLength > 0) {
+		let lineStart = 0;
+		let lineIndex = 0;
+		let newlinePos = contents.indexOf("\n", lineStart);
+		while (newlinePos !== -1) {
+			processLine(s, contents.slice(lineStart, newlinePos + 1), lineIndex);
+			lineStart = newlinePos + 1;
+			lineIndex++;
+			newlinePos = contents.indexOf("\n", lineStart);
 		}
+		if (lineStart < contentLength) processLine(s, contents.slice(lineStart), lineIndex);
+	}
+	if (s.conflictStack.length > 0) throw new Error("parseMergeConflictDiffFromFile: unfinished merge conflict marker stack");
+	if (s.activeHunk != null && s.activeHunk.hunkContent.length > 0) {
+		flushBufferedContext(s, s.activeHunk, "trailing");
+		finalizeActiveHunk(s);
+	}
+	for (let conflictIndex = 0; conflictIndex < s.conflictBuilders.length; conflictIndex++) {
+		const builder = s.conflictBuilders[conflictIndex];
+		if (builder == null || !builder.completed) throw new Error(`parseMergeConflictDiffFromFile: failed to build merge conflict action ${conflictIndex}`);
+	}
+	if (s.hunks.length > 0 && s.additionLines.length > 0 && s.deletionLines.length > 0) {
+		const lastHunk = s.hunks[s.hunks.length - 1];
+		const collapsedAfter = Math.max(s.additionLines.length - (lastHunk.additionStart + lastHunk.additionCount - 1), 0);
+		s.splitLineCount += collapsedAfter;
+		s.unifiedLineCount += collapsedAfter;
 	}
-	const currentContents = currentContentChunks.join("");
-	const incomingContents = incomingContentChunks.join("");
-	const patchContents = patchContentChunks.join("");
+	const currentContents = s.deletionLines.join("");
+	const incomingContents = s.additionLines.join("");
 	const currentFile = createResolvedConflictFile(file, "current", currentContents);
 	const incomingFile = createResolvedConflictFile(file, "incoming", incomingContents);
-	const fileDiff = processFile(createMergeConflictPatch({
+	let type = "change";
+	if (incomingContents === "") type = "deleted";
+	else if (currentContents === "") type = "new";
+	const fileDiff = {
 		name: file.name,
-		patchContents,
-		currentLineCount: currentLineNumber,
-		incomingLineCount: incomingLineNumber
-	}), {
-		oldFile: currentFile,
-		newFile: incomingFile,
-		cacheKey: file.cacheKey != null ? `${file.cacheKey}:merge-conflict-diff` : void 0,
-		throwOnError: true
-	});
-	if (fileDiff == null) throw new Error("parseMergeConflictDiffFromFile: failed to build merge conflict diff metadata");
+		prevName: void 0,
+		type,
+		hunks: s.hunks,
+		splitLineCount: s.splitLineCount,
+		unifiedLineCount: s.unifiedLineCount,
+		isPartial: false,
+		deletionLines: s.deletionLines,
+		additionLines: s.additionLines,
+		cacheKey: file.cacheKey != null ? `${file.cacheKey}:merge-conflict-diff` : void 0
+	};
 	return {
 		fileDiff,
 		currentFile,
 		incomingFile,
-		actions
+		actions: s.actions,
+		markerRows: buildMergeConflictMarkerRows(fileDiff, s.actions)
 	};
 }
-function createMergeConflictPatch({ name, patchContents, currentLineCount, incomingLineCount }) {
-	return `--- ${name}\n+++ ${name}\n@@ -${currentLineCount > 0 ? 1 : 0},${currentLineCount} +${incomingLineCount > 0 ? 1 : 0},${incomingLineCount} @@\n` + patchContents;
+function processLine(s, line, index) {
+	const frame = s.conflictStack[s.conflictStack.length - 1];
+	if (frame == null) {
+		if (line.length >= 7 && line.charCodeAt(0) === 60 && getMergeConflictMarkerType(line) === "start") {
+			handleStartMarker(s, line, index);
+			return;
+		}
+		emitContextLine(s, line);
+		return;
+	}
+	const markerType = getMergeConflictMarkerType(line);
+	if (markerType === "start") {
+		handleStartMarker(s, line, index);
+		return;
+	}
+	if (markerType === "base") {
+		frame.stage = "base";
+		frame.baseMarkerLineIndex = index;
+		frame.markerLines.base = line;
+		return;
+	}
+	if (markerType === "separator") {
+		frame.stage = "incoming";
+		frame.separatorLineIndex = index;
+		frame.markerLines.separator = line;
+		return;
+	}
+	if (markerType === "end") {
+		const completedFrame = s.conflictStack.pop();
+		if (completedFrame == null) throw new Error("parseMergeConflictDiffFromFile: encountered end marker before start marker");
+		finalizeConflict(s, completedFrame, index, line);
+		return;
+	}
+	if (frame.stage === "current") emitChangeLine(s, "deletion", line, frame.conflictIndex, "current");
+	else if (frame.stage === "base") emitContextLine(s, line, frame.conflictIndex);
+	else emitChangeLine(s, "addition", line, frame.conflictIndex, "incoming");
+}
+function ensureActiveHunk(s) {
+	s.activeHunk ??= createHunkBuilder(s.additionLines.length + 1, s.deletionLines.length + 1);
+	return s.activeHunk;
+}
+function assignConflictContent(s, conflictIndex, role, contentIndex) {
+	const builder = s.conflictBuilders[conflictIndex];
+	if (builder == null) throw new Error(`parseMergeConflictDiffFromFile: failed to locate conflict action ${conflictIndex}`);
+	const action = builder.action;
+	const hunkIndex = s.hunks.length;
+	if (action.hunkIndex < 0) action.hunkIndex = hunkIndex;
+	else if (action.hunkIndex !== hunkIndex) throw new Error(`parseMergeConflictDiffFromFile: conflict ${conflictIndex} spans multiple hunks and cannot be anchored`);
+	if (action.startContentIndex < 0) action.startContentIndex = contentIndex;
+	action.endContentIndex = contentIndex;
+	action.endMarkerContentIndex = contentIndex;
+	if (role === "current") {
+		action.currentContentIndex ??= contentIndex;
+		return;
+	}
+	if (role === "base") {
+		action.baseContentIndex ??= contentIndex;
+		return;
+	}
+	action.incomingContentIndex = contentIndex;
+}
+function appendChangeLine(hunk, lineType, additionLineIndex, deletionLineIndex) {
+	const hunkContent = hunk.hunkContent;
+	const lastContent = hunkContent[hunkContent.length - 1];
+	if (lastContent?.type === "change") {
+		if (lineType === "addition") lastContent.additions++;
+		else lastContent.deletions++;
+		return hunkContent.length - 1;
+	}
+	hunkContent.push({
+		type: "change",
+		additions: lineType === "addition" ? 1 : 0,
+		deletions: lineType === "deletion" ? 1 : 0,
+		additionLineIndex,
+		deletionLineIndex
+	});
+	return hunkContent.length - 1;
+}
+function flushBufferedContext(s, hunk, mode) {
+	let count = hunk.contextBufferCount;
+	let addStart = hunk.contextBufferAdditionStart;
+	let delStart = hunk.contextBufferDeletionStart;
+	if (mode === "leading" && count > s.maxContextLines) {
+		const difference = count - s.maxContextLines;
+		addStart += difference;
+		delStart += difference;
+		count = s.maxContextLines;
+		hunk.additionStart += difference;
+		hunk.deletionStart += difference;
+		hunk.additionLineIndex += difference;
+		hunk.deletionLineIndex += difference;
+	}
+	if (mode === "trailing" && count > s.maxContextLines) count = s.maxContextLines;
+	if (count === 0) {
+		hunk.contextBufferCount = 0;
+		hunk.contextBufferBaseConflicts = void 0;
+		return;
+	}
+	const hunkContent = hunk.hunkContent;
+	const lastContent = hunkContent[hunkContent.length - 1];
+	let contentIndex;
+	if (lastContent?.type === "context") {
+		lastContent.lines += count;
+		contentIndex = hunkContent.length - 1;
+	} else {
+		hunkContent.push({
+			type: "context",
+			lines: count,
+			additionLineIndex: addStart,
+			deletionLineIndex: delStart
+		});
+		contentIndex = hunkContent.length - 1;
+	}
+	hunk.additionCount += count;
+	hunk.deletionCount += count;
+	const baseConflicts = hunk.contextBufferBaseConflicts;
+	if (baseConflicts != null) {
+		const bufferStartOffset = addStart - hunk.contextBufferAdditionStart;
+		for (const [offset, conflictIndex] of baseConflicts) if (offset >= bufferStartOffset && offset < bufferStartOffset + count) assignConflictContent(s, conflictIndex, "base", contentIndex);
+	}
+	hunk.contextBufferCount = 0;
+	hunk.contextBufferBaseConflicts = void 0;
+}
+function finalizeActiveHunk(s) {
+	if (s.activeHunk == null) return;
+	const hunk = s.activeHunk;
+	s.activeHunk = void 0;
+	if (hunk.hunkContent.length === 0) return;
+	let hunkSplitLineCount = 0;
+	let hunkUnifiedLineCount = 0;
+	for (const content of hunk.hunkContent) if (content.type === "context") {
+		hunkSplitLineCount += content.lines;
+		hunkUnifiedLineCount += content.lines;
+	} else {
+		hunkSplitLineCount += Math.max(content.additions, content.deletions);
+		hunkUnifiedLineCount += content.additions + content.deletions;
+	}
+	const collapsedBefore = Math.max(hunk.additionStart - 1 - s.lastHunkEnd, 0);
+	const finalizedHunk = {
+		collapsedBefore,
+		additionStart: hunk.additionStart,
+		additionCount: hunk.additionCount,
+		additionLines: hunk.additionLines,
+		additionLineIndex: hunk.additionLineIndex,
+		deletionStart: hunk.deletionStart,
+		deletionCount: hunk.deletionCount,
+		deletionLines: hunk.deletionLines,
+		deletionLineIndex: hunk.deletionLineIndex,
+		hunkContent: hunk.hunkContent,
+		hunkContext: void 0,
+		hunkSpecs: `@@ -${formatHunkRange(hunk.deletionStart, hunk.deletionCount)} +${formatHunkRange(hunk.additionStart, hunk.additionCount)} @@\n`,
+		splitLineStart: s.splitLineCount + collapsedBefore,
+		splitLineCount: hunkSplitLineCount,
+		unifiedLineStart: s.unifiedLineCount + collapsedBefore,
+		unifiedLineCount: hunkUnifiedLineCount,
+		noEOFCRAdditions: false,
+		noEOFCRDeletions: false
+	};
+	s.hunks.push(finalizedHunk);
+	s.splitLineCount += collapsedBefore + hunkSplitLineCount;
+	s.unifiedLineCount += collapsedBefore + hunkUnifiedLineCount;
+	s.lastHunkEnd = hunk.additionStart + hunk.additionCount - 1;
+}
+function splitHunkWithBufferedContext(s) {
+	if (s.activeHunk == null) return;
+	const hunk = s.activeHunk;
+	const count = hunk.contextBufferCount;
+	const omittedContextLineCount = count - s.maxContextLines2;
+	const nextAddStart = hunk.contextBufferAdditionStart + count - s.maxContextLines;
+	const nextDelStart = hunk.contextBufferDeletionStart + count - s.maxContextLines;
+	let nextBaseConflicts;
+	if (hunk.contextBufferBaseConflicts != null) {
+		const tailOffset = count - s.maxContextLines;
+		for (const [offset, ci] of hunk.contextBufferBaseConflicts) if (offset >= tailOffset) {
+			nextBaseConflicts ??= /* @__PURE__ */ new Map();
+			nextBaseConflicts.set(offset - tailOffset, ci);
+		}
+	}
+	flushBufferedContext(s, hunk, "trailing");
+	const emittedAdditionCount = hunk.additionCount;
+	const emittedDeletionCount = hunk.deletionCount;
+	finalizeActiveHunk(s);
+	s.activeHunk = createHunkBuilder(hunk.additionStart + emittedAdditionCount + omittedContextLineCount, hunk.deletionStart + emittedDeletionCount + omittedContextLineCount);
+	s.activeHunk.contextBufferAdditionStart = nextAddStart;
+	s.activeHunk.contextBufferDeletionStart = nextDelStart;
+	s.activeHunk.contextBufferCount = s.maxContextLines;
+	s.activeHunk.contextBufferBaseConflicts = nextBaseConflicts;
+}
+function emitContextLine(s, line, baseConflictIndex = -1) {
+	const hunk = ensureActiveHunk(s);
+	if (hunk.contextBufferCount === 0) {
+		hunk.contextBufferAdditionStart = s.additionLines.length;
+		hunk.contextBufferDeletionStart = s.deletionLines.length;
+	}
+	s.additionLines.push(line);
+	s.deletionLines.push(line);
+	if (baseConflictIndex >= 0) {
+		hunk.contextBufferBaseConflicts ??= /* @__PURE__ */ new Map();
+		hunk.contextBufferBaseConflicts.set(hunk.contextBufferCount, baseConflictIndex);
+	}
+	hunk.contextBufferCount++;
+}
+function emitChangeLine(s, lineType, line, conflictIndex, role) {
+	let hunk = ensureActiveHunk(s);
+	if (hunk.hunkContent.length > 0 && hunk.contextBufferCount > s.maxContextLines2) {
+		splitHunkWithBufferedContext(s);
+		hunk = s.activeHunk;
+	}
+	flushBufferedContext(s, hunk, hunk.hunkContent.length === 0 ? "leading" : "before-change");
+	const additionLineIndex = s.additionLines.length;
+	const deletionLineIndex = s.deletionLines.length;
+	if (lineType === "addition") s.additionLines.push(line);
+	else s.deletionLines.push(line);
+	const contentIndex = appendChangeLine(hunk, lineType, additionLineIndex, deletionLineIndex);
+	if (lineType === "addition") {
+		hunk.additionCount++;
+		hunk.additionLines++;
+	} else {
+		hunk.deletionCount++;
+		hunk.deletionLines++;
+	}
+	assignConflictContent(s, conflictIndex, role, contentIndex);
+}
+function finalizeConflict(s, frame, endLineIndex, endMarkerLine) {
+	if (frame.separatorLineIndex == null || frame.markerLines.separator == null) throw new Error(`parseMergeConflictDiffFromFile: conflict ${frame.conflictIndex} is missing a separator marker`);
+	const builder = s.conflictBuilders[frame.conflictIndex];
+	if (builder == null) throw new Error(`parseMergeConflictDiffFromFile: failed to finalize conflict ${frame.conflictIndex}`);
+	const action = builder.action;
+	action.markerLines.separator = frame.markerLines.separator;
+	action.markerLines.end = endMarkerLine;
+	if (frame.markerLines.base != null) action.markerLines.base = frame.markerLines.base;
+	action.conflict = {
+		conflictIndex: frame.conflictIndex,
+		startLineIndex: frame.startLineIndex,
+		startLineNumber: frame.startLineIndex + 1,
+		separatorLineIndex: frame.separatorLineIndex,
+		separatorLineNumber: frame.separatorLineIndex + 1,
+		endLineIndex,
+		endLineNumber: endLineIndex + 1,
+		baseMarkerLineIndex: frame.baseMarkerLineIndex,
+		baseMarkerLineNumber: frame.baseMarkerLineIndex != null ? frame.baseMarkerLineIndex + 1 : void 0
+	};
+	const fallbackContentIndex = action.currentContentIndex ?? action.incomingContentIndex;
+	action.currentContentIndex ??= fallbackContentIndex;
+	action.incomingContentIndex ??= fallbackContentIndex;
+	if (action.startContentIndex < 0 && fallbackContentIndex != null) action.startContentIndex = fallbackContentIndex;
+	if (action.endContentIndex < 0 && fallbackContentIndex != null) action.endContentIndex = fallbackContentIndex;
+	if (action.endMarkerContentIndex < 0 && fallbackContentIndex != null) action.endMarkerContentIndex = fallbackContentIndex;
+	if (action.hunkIndex < 0 || action.startContentIndex < 0 || action.endContentIndex < 0 || action.endMarkerContentIndex < 0) throw new Error(`parseMergeConflictDiffFromFile: failed to anchor merge conflict ${frame.conflictIndex}`);
+	s.actions[action.conflictIndex] = action;
+	builder.completed = true;
+}
+function handleStartMarker(s, line, lineIndex) {
+	const conflictIndex = s.nextConflictIndex;
+	s.nextConflictIndex++;
+	s.conflictStack.push({
+		conflictIndex,
+		stage: "current",
+		startLineIndex: lineIndex,
+		markerLines: { start: line }
+	});
+	s.conflictBuilders[conflictIndex] = {
+		completed: false,
+		action: {
+			conflict: {
+				conflictIndex,
+				startLineIndex: lineIndex,
+				startLineNumber: lineIndex + 1,
+				separatorLineIndex: lineIndex,
+				separatorLineNumber: lineIndex + 1,
+				endLineIndex: lineIndex,
+				endLineNumber: lineIndex + 1,
+				baseMarkerLineIndex: void 0,
+				baseMarkerLineNumber: void 0
+			},
+			conflictIndex,
+			hunkIndex: -1,
+			startContentIndex: -1,
+			endContentIndex: -1,
+			endMarkerContentIndex: -1,
+			markerLines: {
+				start: line,
+				separator: "",
+				end: ""
+			}
+		}
+	};
+}
+function createHunkBuilder(additionStart, deletionStart) {
+	return {
+		additionStart,
+		deletionStart,
+		additionCount: 0,
+		deletionCount: 0,
+		additionLines: 0,
+		deletionLines: 0,
+		additionLineIndex: Math.max(additionStart - 1, 0),
+		deletionLineIndex: Math.max(deletionStart - 1, 0),
+		hunkContent: [],
+		contextBufferAdditionStart: Math.max(additionStart - 1, 0),
+		contextBufferDeletionStart: Math.max(deletionStart - 1, 0),
+		contextBufferCount: 0,
+		contextBufferBaseConflicts: void 0
+	};
+}
+function formatHunkRange(start, count) {
+	return count === 1 ? `${start}` : `${start},${count}`;
+}
+function getMergeConflictMarkerType(line) {
+	if (line.length < 7) return;
+	const markerCode = line.charCodeAt(0);
+	if (markerCode !== 60 && markerCode !== 62 && markerCode !== 61 && markerCode !== 124) return;
+	const lineEnd = getLineContentEndIndex(line);
+	if (lineEnd < 7) return;
+	let markerLength = 1;
+	while (markerLength < lineEnd && line.charCodeAt(markerLength) === markerCode) markerLength++;
+	if (markerLength < 7) return;
+	if (markerCode === 61) return markerLength === lineEnd ? "separator" : void 0;
+	if (markerLength !== lineEnd && !isWhitespaceCode(line.charCodeAt(markerLength))) return;
+	if (markerCode === 60) return "start";
+	if (markerCode === 62) return "end";
+	return "base";
+}
+function getLineContentEndIndex(line) {
+	let end = line.length;
+	if (end > 0 && line.charCodeAt(end - 1) === 10) end--;
+	if (end > 0 && line.charCodeAt(end - 1) === 13) end--;
+	return end;
+}
+function isWhitespaceCode(code) {
+	return code === 9 || code === 10 || code === 11 || code === 12 || code === 13 || code === 32;
 }
 function createResolvedConflictFile(file, side, contents) {
 	return {
@@ -134,10 +419,82 @@ function createResolvedConflictFile(file, side, contents) {
 		cacheKey: file.cacheKey != null ? `${file.cacheKey}:merge-conflict-${side}` : void 0
 	};
 }
-function assertNever(value) {
-	throw new Error(`parseMergeConflictDiffFromFile: unknown merge conflict line type ${String(value)}`);
+function buildMergeConflictMarkerRows(fileDiff, actions) {
+	const markerRows = [];
+	const hunkLineStartCache = new Array(fileDiff.hunks.length);
+	const getLineStart = (hunkIndex, contentIndex) => {
+		const hunk = fileDiff.hunks[hunkIndex];
+		if (hunk == null) return 0;
+		let starts = hunkLineStartCache[hunkIndex];
+		if (starts == null) {
+			starts = new Array(hunk.hunkContent.length + 1);
+			let lineIndex = hunk.unifiedLineStart;
+			starts[0] = lineIndex;
+			for (let index = 0; index < hunk.hunkContent.length; index++) {
+				const content = hunk.hunkContent[index];
+				lineIndex += content.type === "context" ? content.lines : content.deletions + content.additions;
+				starts[index + 1] = lineIndex;
+			}
+			hunkLineStartCache[hunkIndex] = starts;
+		}
+		return starts[Math.max(contentIndex, 0)] ?? hunk.unifiedLineStart;
+	};
+	const getLineEnd = (hunkIndex, contentIndex) => {
+		const lineStart = getLineStart(hunkIndex, contentIndex);
+		const lineEndExclusive = hunkLineStartCache[hunkIndex]?.[Math.max(contentIndex + 1, 0)] ?? getLineStart(hunkIndex, contentIndex + 1);
+		return Math.max(lineStart, lineEndExclusive - 1);
+	};
+	for (const action of actions) {
+		if (action == null) continue;
+		const hunk = fileDiff.hunks[action.hunkIndex];
+		if (hunk == null) continue;
+		const actionLineIndex = getLineStart(action.hunkIndex, action.startContentIndex);
+		markerRows.push(createMergeConflictMarkerRow(action, "marker-start", action.startContentIndex, action.markerLines.start, actionLineIndex));
+		if (action.baseContentIndex != null) {
+			const currentContentIndex$1 = action.currentContentIndex;
+			const incomingContentIndex = action.incomingContentIndex;
+			if (currentContentIndex$1 == null || incomingContentIndex == null) continue;
+			const baseMarkerLine = action.markerLines.base;
+			if (baseMarkerLine == null) continue;
+			const currentChange = hunk.hunkContent[currentContentIndex$1];
+			const baseContext = hunk.hunkContent[action.baseContentIndex];
+			const incomingChange = hunk.hunkContent[incomingContentIndex];
+			if (currentChange?.type !== "change" || baseContext?.type !== "context" || incomingChange?.type !== "change") continue;
+			const currentStart = getLineStart(action.hunkIndex, currentContentIndex$1);
+			const incomingStart = getLineStart(action.hunkIndex, incomingContentIndex);
+			markerRows.push(createMergeConflictMarkerRow(action, "marker-base", action.baseContentIndex, baseMarkerLine, currentStart + currentChange.deletions));
+			markerRows.push(createMergeConflictMarkerRow(action, "marker-separator", action.baseContentIndex, action.markerLines.separator, incomingStart), createMergeConflictMarkerRow(action, "marker-end", action.endMarkerContentIndex, action.markerLines.end, getLineEnd(action.hunkIndex, action.endMarkerContentIndex)));
+			continue;
+		}
+		const currentContentIndex = action.currentContentIndex;
+		if (currentContentIndex == null) continue;
+		const content = hunk.hunkContent[currentContentIndex];
+		if (content?.type !== "change") continue;
+		const contentStart = getLineStart(action.hunkIndex, currentContentIndex);
+		const separatorLineIndex = content.deletions > 0 ? contentStart + content.deletions : actionLineIndex;
+		markerRows.push(createMergeConflictMarkerRow(action, "marker-separator", currentContentIndex, action.markerLines.separator, separatorLineIndex), createMergeConflictMarkerRow(action, "marker-end", action.endMarkerContentIndex, action.markerLines.end, getLineEnd(action.hunkIndex, action.endMarkerContentIndex)));
+	}
+	return markerRows;
+}
+function createMergeConflictMarkerRow(action, type, contentIndex, lineText, lineIndex) {
+	return {
+		type,
+		hunkIndex: action.hunkIndex,
+		contentIndex,
+		conflictIndex: action.conflictIndex,
+		lineText,
+		lineIndex
+	};
+}
+function getUnifiedLineStartForContent(hunk, contentIndex) {
+	let lineIndex = hunk.unifiedLineStart;
+	for (let index = 0; index < contentIndex; index++) {
+		const content = hunk.hunkContent[index];
+		lineIndex += content.type === "context" ? content.lines : content.deletions + content.additions;
+	}
+	return lineIndex;
 }
 
 //#endregion
-export { getMergeConflictActionAnchor, parseMergeConflictDiffFromFile };
+export { buildMergeConflictMarkerRows, getMergeConflictActionAnchor, parseMergeConflictDiffFromFile };
 //# sourceMappingURL=parseMergeConflictDiffFromFile.js.map