@pierre/diffs 1.2.6 → 1.3.0-beta.1

package/dist/worker/worker.js

@@ -12,7 +12,6 @@ const DIFFS_DEVELOPMENT_BUILD = (() => {
 		return false;
 	}
 })();
-const SPLIT_WITH_NEWLINES = /(?<=\n)/;
 const DEFAULT_THEMES = {
 	dark: "pierre-dark",
 	light: "pierre-light"
@@ -454,7 +453,12 @@ function replaceCustomExtensions(version, map) {
 //#endregion
 //#region src/utils/cleanLastNewline.ts
 function cleanLastNewline(contents) {
-	return contents.replace(/\n$|\r\n$/, "");
+	let end = contents.length;
+	if (contents.charCodeAt(end - 1) === 10) {
+		end--;
+		if (contents.charCodeAt(end - 1) === 13) end--;
+	}
+	return contents.slice(0, end);
 }
 
 //#endregion
@@ -631,6 +635,15 @@ function createTransformerWithState(useTokenTransformer = false, useCSSClasses =
 		} : null
 	}];
 	if (useCSSClasses) transformers.push(tokenStyleNormalizer, toClass);
+	if (useTokenTransformer) transformers.push({ line: (node) => {
+		if (node.type === "element" && node.children.length === 0) node.children.push({
+			type: "element",
+			tagName: "br",
+			properties: {},
+			children: []
+		});
+		return node;
+	} });
 	return {
 		state,
 		transformers,
@@ -741,39 +754,6 @@ function getExpandedRegion({ isPartial, rangeSize, expandedHunks, hunkIndex, col
 		renderAll
 	};
 }
-function getTrailingContextRangeSize({ fileDiff, errorPrefix }) {
-	const lastHunk = fileDiff.hunks[fileDiff.hunks.length - 1];
-	if (lastHunk == null || fileDiff.isPartial || fileDiff.additionLines.length === 0 || fileDiff.deletionLines.length === 0) return 0;
-	const additionRemaining = fileDiff.additionLines.length - (lastHunk.additionLineIndex + lastHunk.additionCount);
-	const deletionRemaining = fileDiff.deletionLines.length - (lastHunk.deletionLineIndex + lastHunk.deletionCount);
-	if (additionRemaining <= 0 && deletionRemaining <= 0) return 0;
-	if (additionRemaining !== deletionRemaining) throw new Error(`${errorPrefix}: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${fileDiff.name}`);
-	return Math.min(additionRemaining, deletionRemaining);
-}
-function getTrailingExpandedRegion({ fileDiff, hunkIndex, expandedHunks, collapsedContextThreshold, errorPrefix }) {
-	if (hunkIndex !== fileDiff.hunks.length - 1) return;
-	const trailingRangeSize = getTrailingContextRangeSize({
-		fileDiff,
-		errorPrefix
-	});
-	if (trailingRangeSize <= 0) return;
-	if (expandedHunks === true || trailingRangeSize <= collapsedContextThreshold) return {
-		fromStart: trailingRangeSize,
-		fromEnd: 0,
-		rangeSize: trailingRangeSize,
-		collapsedLines: 0,
-		renderAll: true
-	};
-	const region = expandedHunks?.get(fileDiff.hunks.length);
-	const fromStart = Math.min(Math.max(region?.fromStart ?? 0, 0), trailingRangeSize);
-	return {
-		fromStart,
-		fromEnd: 0,
-		rangeSize: trailingRangeSize,
-		collapsedLines: trailingRangeSize - fromStart,
-		renderAll: fromStart >= trailingRangeSize
-	};
-}
 
 //#endregion
 //#region src/utils/iterateOverDiff.ts
@@ -786,12 +766,12 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 		collapsedContextThreshold
 	});
 	const state = {
+		finalHunk: diff.hunks.at(-1),
 		viewportStart: startingLine,
 		viewportEnd: startingLine + totalLines,
 		isWindowedHighlight: startingLine > 0 || totalLines < Infinity,
 		splitCount: iterationStart.splitCount,
 		unifiedCount: iterationStart.unifiedCount,
-		finalHunkIndex: diff.hunks.length - 1,
 		shouldBreak() {
 			if (!state.isWindowedHighlight) return false;
 			const breakUnified = state.unifiedCount >= startingLine + totalLines;
@@ -844,24 +824,31 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			hunkIndex,
 			collapsedContextThreshold
 		});
-		const trailingRegion = hunkIndex === state.finalHunkIndex ? getTrailingExpandedRegion({
-			fileDiff: diff,
-			hunkIndex,
-			expandedHunks,
-			collapsedContextThreshold,
-			errorPrefix: "iterateOverDiff"
-		}) : void 0;
+		const trailingRegion = (() => {
+			if (hunk !== state.finalHunk || !hasFinalCollapsedHunk(diff)) return;
+			const additionRemaining = diff.additionLines.length - (hunk.additionLineIndex + hunk.additionCount);
+			const deletionRemaining = diff.deletionLines.length - (hunk.deletionLineIndex + hunk.deletionCount);
+			if (additionRemaining !== deletionRemaining) throw new Error(`iterateOverDiff: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${diff.name}`);
+			const trailingRangeSize = Math.min(additionRemaining, deletionRemaining);
+			return getExpandedRegion({
+				isPartial: diff.isPartial,
+				rangeSize: trailingRangeSize,
+				expandedHunks,
+				hunkIndex: diff.hunks.length,
+				collapsedContextThreshold
+			});
+		})();
 		const expandedLineCount = leadingRegion.fromStart + leadingRegion.fromEnd;
 		function getTrailingCollapsedAfter(unifiedLineIndex$1, splitLineIndex$1) {
 			if (trailingRegion == null || trailingRegion.collapsedLines <= 0 || trailingRegion.fromStart + trailingRegion.fromEnd > 0) return 0;
 			if (diffStyle === "unified") return unifiedLineIndex$1 === hunk.unifiedLineStart + hunk.unifiedLineCount - 1 ? trailingRegion.collapsedLines : 0;
 			return splitLineIndex$1 === hunk.splitLineStart + hunk.splitLineCount - 1 ? trailingRegion.collapsedLines : 0;
 		}
-		let consumedCollapsed = leadingRegion.collapsedLines === 0;
-		function consumePendingCollapsed() {
-			if (consumedCollapsed) return 0;
-			consumedCollapsed = true;
-			return leadingRegion.collapsedLines;
+		function getPendingCollapsed() {
+			if (leadingRegion.collapsedLines === 0) return 0;
+			const value = leadingRegion.collapsedLines;
+			leadingRegion.collapsedLines = 0;
+			return value;
 		}
 		if (!state.shouldSkip(expandedLineCount, expandedLineCount)) {
 			let unifiedLineIndex$1 = hunk.unifiedLineStart - leadingRegion.rangeSize;
@@ -870,63 +857,81 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			let additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.rangeSize;
 			let deletionLineNumber$1 = hunk.deletionStart - leadingRegion.rangeSize;
 			let additionLineNumber$1 = hunk.additionStart - leadingRegion.rangeSize;
-			if (walkContextLines(state, leadingRegion.fromStart, diffStyle, (index) => {
-				return state.emit({
-					hunkIndex,
-					hunk,
-					collapsedBefore: 0,
-					collapsedAfter: 0,
-					type: "context-expanded",
-					deletionLine: {
-						lineNumber: deletionLineNumber$1 + index,
-						lineIndex: deletionLineIndex$1 + index,
-						noEOFCR: false,
-						unifiedLineIndex: unifiedLineIndex$1 + index,
-						splitLineIndex: splitLineIndex$1 + index
-					},
-					additionLine: {
-						unifiedLineIndex: unifiedLineIndex$1 + index,
-						splitLineIndex: splitLineIndex$1 + index,
-						lineIndex: additionLineIndex$1 + index,
-						lineNumber: additionLineNumber$1 + index,
-						noEOFCR: false
-					}
-				});
-			})) break hunkIterator;
+			const [startIndex, endIndex] = getEqualLineIterationRange(state, leadingRegion.fromStart, diffStyle);
+			if (startIndex > 0) state.incrementCounts(startIndex, startIndex);
+			let index = startIndex;
+			while (index < leadingRegion.fromStart) {
+				if (index >= endIndex) {
+					state.incrementCounts(leadingRegion.fromStart - index, leadingRegion.fromStart - index);
+					break;
+				}
+				if (state.isInWindow(0, 0)) {
+					if (state.emit({
+						hunkIndex,
+						hunk,
+						collapsedBefore: 0,
+						collapsedAfter: 0,
+						type: "context-expanded",
+						deletionLine: {
+							lineNumber: deletionLineNumber$1 + index,
+							lineIndex: deletionLineIndex$1 + index,
+							noEOFCR: false,
+							unifiedLineIndex: unifiedLineIndex$1 + index,
+							splitLineIndex: splitLineIndex$1 + index
+						},
+						additionLine: {
+							unifiedLineIndex: unifiedLineIndex$1 + index,
+							splitLineIndex: splitLineIndex$1 + index,
+							lineIndex: additionLineIndex$1 + index,
+							lineNumber: additionLineNumber$1 + index,
+							noEOFCR: false
+						}
+					})) break hunkIterator;
+				} else state.incrementCounts(1, 1);
+				index++;
+			}
 			unifiedLineIndex$1 = hunk.unifiedLineStart - leadingRegion.fromEnd;
 			splitLineIndex$1 = hunk.splitLineStart - leadingRegion.fromEnd;
 			deletionLineIndex$1 = hunk.deletionLineIndex - leadingRegion.fromEnd;
 			additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.fromEnd;
 			deletionLineNumber$1 = hunk.deletionStart - leadingRegion.fromEnd;
 			additionLineNumber$1 = hunk.additionStart - leadingRegion.fromEnd;
-			if (walkContextLines(state, leadingRegion.fromEnd, diffStyle, (index) => {
-				return state.emit({
-					hunkIndex,
-					hunk,
-					collapsedBefore: consumePendingCollapsed(),
-					collapsedAfter: 0,
-					type: "context-expanded",
-					deletionLine: {
-						lineNumber: deletionLineNumber$1 + index,
-						lineIndex: deletionLineIndex$1 + index,
-						noEOFCR: false,
-						unifiedLineIndex: unifiedLineIndex$1 + index,
-						splitLineIndex: splitLineIndex$1 + index
-					},
-					additionLine: {
-						unifiedLineIndex: unifiedLineIndex$1 + index,
-						splitLineIndex: splitLineIndex$1 + index,
-						lineIndex: additionLineIndex$1 + index,
-						lineNumber: additionLineNumber$1 + index,
-						noEOFCR: false
-					}
-				});
-			}, () => {
-				consumePendingCollapsed();
-			})) break hunkIterator;
+			const [fromEndStartIndex, fromEndEndIndex] = getEqualLineIterationRange(state, leadingRegion.fromEnd, diffStyle);
+			if (fromEndStartIndex > 0) state.incrementCounts(fromEndStartIndex, fromEndStartIndex);
+			index = fromEndStartIndex;
+			while (index < leadingRegion.fromEnd) {
+				if (index >= fromEndEndIndex) {
+					state.incrementCounts(leadingRegion.fromEnd - index, leadingRegion.fromEnd - index);
+					break;
+				}
+				if (state.isInWindow(0, 0)) {
+					if (state.emit({
+						hunkIndex,
+						hunk,
+						collapsedBefore: getPendingCollapsed(),
+						collapsedAfter: 0,
+						type: "context-expanded",
+						deletionLine: {
+							lineNumber: deletionLineNumber$1 + index,
+							lineIndex: deletionLineIndex$1 + index,
+							noEOFCR: false,
+							unifiedLineIndex: unifiedLineIndex$1 + index,
+							splitLineIndex: splitLineIndex$1 + index
+						},
+						additionLine: {
+							unifiedLineIndex: unifiedLineIndex$1 + index,
+							splitLineIndex: splitLineIndex$1 + index,
+							lineIndex: additionLineIndex$1 + index,
+							lineNumber: additionLineNumber$1 + index,
+							noEOFCR: false
+						}
+					})) break hunkIterator;
+				} else state.incrementCounts(1, 1);
+				index++;
+			}
 		} else {
 			state.incrementCounts(expandedLineCount, expandedLineCount);
-			consumePendingCollapsed();
+			getPendingCollapsed();
 		}
 		let unifiedLineIndex = hunk.unifiedLineStart;
 		let splitLineIndex = hunk.splitLineStart;
@@ -940,37 +945,45 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			const isLastContent = content === lastContent;
 			if (content.type === "context") {
 				if (!state.shouldSkip(content.lines, content.lines)) {
-					if (walkContextLines(state, content.lines, diffStyle, (index) => {
-						const isLastLine = isLastContent && index === content.lines - 1;
-						const unifiedRowIndex = unifiedLineIndex + index;
-						const splitRowIndex = splitLineIndex + index;
-						return state.emit({
-							hunkIndex,
-							hunk,
-							collapsedBefore: consumePendingCollapsed(),
-							collapsedAfter: getTrailingCollapsedAfter(unifiedRowIndex, splitRowIndex),
-							type: "context",
-							deletionLine: {
-								lineNumber: deletionLineNumber + index,
-								lineIndex: deletionLineIndex + index,
-								noEOFCR: isLastLine && hunk.noEOFCRDeletions,
-								unifiedLineIndex: unifiedRowIndex,
-								splitLineIndex: splitRowIndex
-							},
-							additionLine: {
-								unifiedLineIndex: unifiedRowIndex,
-								splitLineIndex: splitRowIndex,
-								lineIndex: additionLineIndex + index,
-								lineNumber: additionLineNumber + index,
-								noEOFCR: isLastLine && hunk.noEOFCRAdditions
-							}
-						});
-					}, () => {
-						consumePendingCollapsed();
-					})) break hunkIterator;
+					const [startIndex, endIndex] = getEqualLineIterationRange(state, content.lines, diffStyle);
+					if (startIndex > 0) state.incrementCounts(startIndex, startIndex);
+					let index = startIndex;
+					while (index < content.lines) {
+						if (index >= endIndex) {
+							state.incrementCounts(content.lines - index, content.lines - index);
+							break;
+						}
+						if (state.isInWindow(0, 0)) {
+							const isLastLine = isLastContent && index === content.lines - 1;
+							const unifiedRowIndex = unifiedLineIndex + index;
+							const splitRowIndex = splitLineIndex + index;
+							if (state.emit({
+								hunkIndex,
+								hunk,
+								collapsedBefore: getPendingCollapsed(),
+								collapsedAfter: getTrailingCollapsedAfter(unifiedRowIndex, splitRowIndex),
+								type: "context",
+								deletionLine: {
+									lineNumber: deletionLineNumber + index,
+									lineIndex: deletionLineIndex + index,
+									noEOFCR: isLastLine && hunk.noEOFCRDeletions,
+									unifiedLineIndex: unifiedRowIndex,
+									splitLineIndex: splitRowIndex
+								},
+								additionLine: {
+									unifiedLineIndex: unifiedRowIndex,
+									splitLineIndex: splitRowIndex,
+									lineIndex: additionLineIndex + index,
+									lineNumber: additionLineNumber + index,
+									noEOFCR: isLastLine && hunk.noEOFCRAdditions
+								}
+							})) break hunkIterator;
+						} else state.incrementCounts(1, 1);
+						index++;
+					}
 				} else {
 					state.incrementCounts(content.lines, content.lines);
-					consumePendingCollapsed();
+					getPendingCollapsed();
 				}
 				unifiedLineIndex += content.lines;
 				splitLineIndex += content.lines;
@@ -983,13 +996,12 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 				const unifiedCount = content.deletions + content.additions;
 				if (!state.shouldSkip(unifiedCount, splitCount)) {
 					const iterationRanges = getChangeIterationRanges(state, content, diffStyle);
-					if ((iterationRanges[0]?.[0] ?? 0) > 0) consumePendingCollapsed();
 					for (const [rangeStart, rangeEnd] of iterationRanges) for (let index = rangeStart; index < rangeEnd; index++) {
 						const collapsedAfter = getTrailingCollapsedAfter(unifiedLineIndex + index, diffStyle === "unified" ? splitLineIndex + (index < content.deletions ? index : index - content.deletions) : splitLineIndex + index);
 						if (state.emit(getChangeLineData({
 							hunkIndex,
 							hunk,
-							collapsedBefore: consumePendingCollapsed(),
+							collapsedBefore: getPendingCollapsed(),
 							collapsedAfter,
 							diffStyle,
 							index,
@@ -1006,7 +1018,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 						}), true)) break hunkIterator;
 					}
 				}
-				consumePendingCollapsed();
+				getPendingCollapsed();
 				state.incrementCounts(unifiedCount, splitCount);
 				unifiedLineIndex += unifiedCount;
 				splitLineIndex += splitCount;
@@ -1019,30 +1031,41 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 		if (trailingRegion != null) {
 			const { collapsedLines, fromStart, fromEnd } = trailingRegion;
 			const len = fromStart + fromEnd;
-			if (walkContextLines(state, len, diffStyle, (index) => {
-				const isLastLine = index === len - 1;
-				return state.emit({
-					hunkIndex: diff.hunks.length,
-					hunk: void 0,
-					collapsedBefore: 0,
-					collapsedAfter: isLastLine ? collapsedLines : 0,
-					type: "context-expanded",
-					deletionLine: {
-						lineNumber: deletionLineNumber + index,
-						lineIndex: deletionLineIndex + index,
-						noEOFCR: false,
-						unifiedLineIndex: unifiedLineIndex + index,
-						splitLineIndex: splitLineIndex + index
-					},
-					additionLine: {
-						unifiedLineIndex: unifiedLineIndex + index,
-						splitLineIndex: splitLineIndex + index,
-						lineIndex: additionLineIndex + index,
-						lineNumber: additionLineNumber + index,
-						noEOFCR: false
-					}
-				});
-			}, void 0, () => state.shouldBreak())) break hunkIterator;
+			const [startIndex, endIndex] = getEqualLineIterationRange(state, len, diffStyle);
+			if (startIndex > 0) state.incrementCounts(startIndex, startIndex);
+			let index = startIndex;
+			while (index < len) {
+				if (state.shouldBreak()) break hunkIterator;
+				if (index >= endIndex) {
+					state.incrementCounts(len - index, len - index);
+					break;
+				}
+				if (state.isInWindow(0, 0)) {
+					const isLastLine = index === len - 1;
+					if (state.emit({
+						hunkIndex: diff.hunks.length,
+						hunk: void 0,
+						collapsedBefore: 0,
+						collapsedAfter: isLastLine ? collapsedLines : 0,
+						type: "context-expanded",
+						deletionLine: {
+							lineNumber: deletionLineNumber + index,
+							lineIndex: deletionLineIndex + index,
+							noEOFCR: false,
+							unifiedLineIndex: unifiedLineIndex + index,
+							splitLineIndex: splitLineIndex + index
+						},
+						additionLine: {
+							unifiedLineIndex: unifiedLineIndex + index,
+							splitLineIndex: splitLineIndex + index,
+							lineIndex: additionLineIndex + index,
+							lineNumber: additionLineNumber + index,
+							noEOFCR: false
+						}
+					})) break hunkIterator;
+				} else state.incrementCounts(1, 1);
+				index++;
+			}
 		}
 	}
 }
@@ -1107,14 +1130,15 @@ function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold })
 		const leadingCount = leadingRegion.fromStart + leadingRegion.fromEnd;
 		splitCount += leadingCount + hunk.splitLineCount;
 		unifiedCount += leadingCount + hunk.unifiedLineCount;
-		const trailingRegion = index === finalHunkIndex ? getTrailingExpandedRegion({
-			fileDiff: diff,
-			hunkIndex: index,
-			expandedHunks,
-			collapsedContextThreshold,
-			errorPrefix: "iterateOverDiff"
-		}) : void 0;
-		if (trailingRegion != null) {
+		if (index === finalHunkIndex && hasFinalCollapsedHunk(diff)) {
+			const trailingRangeSize = getTrailingRangeSize(diff, hunk);
+			const trailingRegion = getExpandedRegion({
+				isPartial: diff.isPartial,
+				rangeSize: trailingRangeSize,
+				expandedHunks,
+				hunkIndex: diff.hunks.length,
+				collapsedContextThreshold
+			});
 			const trailingCount = trailingRegion.fromStart + trailingRegion.fromEnd;
 			splitCount += trailingCount;
 			unifiedCount += trailingCount;
@@ -1126,7 +1150,7 @@ function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold })
 	}
 	return prefixCounts;
 }
-function getContextLineIterationBounds(state, count, diffStyle) {
+function getEqualLineIterationRange(state, count, diffStyle) {
 	if (!state.isWindowedHighlight || count <= 0) return [0, count];
 	const ranges = [];
 	function pushRange(currentCount) {
@@ -1146,25 +1170,16 @@ function getContextLineIterationBounds(state, count, diffStyle) {
 	}
 	return [start, end];
 }
-function walkContextLines(state, count, diffStyle, callback, onSkippedStart, shouldBreak) {
-	const [startIndex, endIndex] = getContextLineIterationBounds(state, count, diffStyle);
-	if (startIndex > 0) {
-		state.incrementCounts(startIndex, startIndex);
-		onSkippedStart?.();
-	}
-	let index = startIndex;
-	while (index < count) {
-		if (shouldBreak?.() === true) return true;
-		if (index >= endIndex) {
-			state.incrementCounts(count - index, count - index);
-			break;
-		}
-		if (state.isInWindow(0, 0)) {
-			if (callback(index) === true) return true;
-		} else state.incrementCounts(1, 1);
-		index++;
-	}
-	return false;
+function getTrailingRangeSize(diff, hunk) {
+	const additionRemaining = diff.additionLines.length - (hunk.additionLineIndex + hunk.additionCount);
+	const deletionRemaining = diff.deletionLines.length - (hunk.deletionLineIndex + hunk.deletionCount);
+	if (additionRemaining !== deletionRemaining) throw new Error(`iterateOverDiff: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${diff.name}`);
+	return Math.min(additionRemaining, deletionRemaining);
+}
+function hasFinalCollapsedHunk(diff) {
+	const lastHunk = diff.hunks.at(-1);
+	if (lastHunk == null || diff.isPartial || diff.additionLines.length === 0 || diff.deletionLines.length === 0) return false;
+	return lastHunk.additionLineIndex + lastHunk.additionCount < diff.additionLines.length || lastHunk.deletionLineIndex + lastHunk.deletionCount < diff.deletionLines.length;
 }
 function getChangeIterationRanges(state, content, diffStyle) {
 	if (!state.isWindowedHighlight) return [[0, diffStyle === "unified" ? content.deletions + content.additions : Math.max(content.deletions, content.additions)]];
@@ -1540,63 +1555,34 @@ function renderTwoFiles({ deletionFile, additionFile, deletionInfo, additionInfo
 }
 
 //#endregion
-//#region src/utils/iterateOverFile.ts
+//#region src/utils/computeFileOffsets.ts
+const LINE_FEED = 10;
+const CARRIAGE_RETURN = 13;
 /**
-* Iterates over lines in a file with optional windowing support.
-*
-* Similar to `iterateOverDiff` but simplified for linear file content.
-* Supports viewport windowing for virtualization scenarios.
-*
-* @param props - Configuration for iteration
-* @param props.lines - Pre-split array of lines (use splitFileContents() to create from string)
-* @param props.startingLine - Optional starting line index (0-based, default: 0)
-* @param props.totalLines - Optional max lines to iterate (default: Infinity)
-* @param props.callback - Callback invoked for each line in the window.
-*                         Return `true` to stop iteration early.
-*
-* @example
-* ```typescript
-* const lines = splitFileContents('line1\nline2\nline3');
-* iterateOverFile({
-*   lines,
-*   startingLine: 0,
-*   totalLines: 10,
-*   callback: ({ lineIndex, lineNumber, content, isLastLine }) => {
-*     console.log(`Line ${lineNumber}: ${content}`);
-*     if (content.includes('stop')) return true; // Stop iteration
-*   }
-* });
-* ```
+* Computes line start offsets for a string.
 */
-function iterateOverFile({ lines, startingLine = 0, totalLines = Infinity, callback }) {
-	const len = Math.min(startingLine + totalLines, lines.length);
-	const lastLineIndex = (() => {
-		const lastLine = lines.at(-1);
-		if (lastLine === "" || lastLine === "\n" || lastLine === "\r\n" || lastLine === "\r") return Math.max(0, lines.length - 2);
-		return lines.length - 1;
-	})();
-	for (let lineIndex = startingLine; lineIndex < len; lineIndex++) {
-		const isLastLine = lineIndex === lastLineIndex;
-		if (callback({
-			lineIndex,
-			lineNumber: lineIndex + 1,
-			content: lines[lineIndex],
-			isLastLine
-		}) === true || isLastLine) break;
+function computeLineOffsets(contents) {
+	const offsets = [0];
+	for (let i = 0; i < contents.length; i++) {
+		const char = contents.charCodeAt(i);
+		if (char === LINE_FEED || char === CARRIAGE_RETURN) {
+			if (char === CARRIAGE_RETURN && i + 1 < contents.length && contents.charCodeAt(i + 1) === LINE_FEED) i++;
+			offsets.push(i + 1);
+		}
 	}
+	return offsets;
 }
-
-//#endregion
-//#region src/utils/splitFileContents.ts
 /**
-* Splits file contents into lines using the same logic as diff parsing.
-* - Preserves trailing newlines on each line
-*
-* @param contents - The raw file contents string
-* @returns Array of lines with newlines preserved
+* Splits file contents into lines aligned with {@link computeLineOffsets}.
+* Unlike splitFileContents, a trailing newline produces a final empty line.
 */
-function splitFileContents(contents) {
-	return contents !== "" ? contents.split(SPLIT_WITH_NEWLINES) : [];
+function linesFromFileContents(contents) {
+	const offsets = computeLineOffsets(contents);
+	return Array.from({ length: offsets.length }, (_, i) => {
+		const start = offsets[i];
+		const end = offsets[i + 1] ?? contents.length;
+		return contents.slice(start, end);
+	});
 }
 
 //#endregion
@@ -1641,7 +1627,7 @@ function renderFileWithHighlighter(file, highlighter$1, { theme = DEFAULT_THEMES
 			tokenizeMaxLineLength
 		};
 	})();
-	const highlightedLines = getLineNodes(highlighter$1.codeToHast(isWindowedHighlight ? extractWindowedFileContent(lines ?? splitFileContents(file.contents), startingLine, totalLines) : cleanLastNewline(file.contents), hastConfig));
+	const highlightedLines = getLineNodes(highlighter$1.codeToHast(isWindowedHighlight ? extractWindowedFileContent(lines ?? linesFromFileContents(file.contents), startingLine, totalLines) : file.contents, hastConfig));
 	const code = isWindowedHighlight ? new Array(startingLine) : highlightedLines;
 	if (isWindowedHighlight) code.push(...highlightedLines);
 	return {
@@ -1651,16 +1637,9 @@ function renderFileWithHighlighter(file, highlighter$1, { theme = DEFAULT_THEMES
 	};
 }
 function extractWindowedFileContent(lines, startingLine, totalLines) {
-	let windowContent = "";
-	iterateOverFile({
-		lines,
-		startingLine,
-		totalLines,
-		callback({ content }) {
-			windowContent += content;
-		}
-	});
-	return windowContent;
+	if (lines.length === 0) return "";
+	const endLine = Math.min(startingLine + totalLines, lines.length);
+	return lines.slice(startingLine, endLine).join("");
 }
 
 //#endregion