@pierre/diffs 1.3.0-beta.2 → 1.3.0-beta.4

package/dist/worker/worker.js

@@ -1,8 +1,10 @@
 import { createHighlighterCore } from "shiki/core";
 import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
 import { createOnigurumaEngine } from "shiki/engine/oniguruma";
+import { createThemeResolver } from "@pierre/theming";
 import { diffChars, diffWordsWithSpace } from "diff";
 import { transformerStyleToClass } from "@shikijs/transformers";
+import { normalizeThemeColors } from "@pierre/theming/color";
 
 //#region src/constants.ts
 const DIFFS_DEVELOPMENT_BUILD = (() => {
@@ -55,9 +57,12 @@ function attachResolvedLanguages(resolvedLanguages, highlighter$1) {
 
 //#endregion
 //#region src/highlighter/themes/constants.ts
-const ResolvedThemes = /* @__PURE__ */ new Map();
 const AttachedThemes = /* @__PURE__ */ new Set();
 
+//#endregion
+//#region src/highlighter/themes/themeResolver.ts
+const themeResolver = createThemeResolver();
+
 //#endregion
 //#region src/highlighter/themes/attachResolvedThemes.ts
 function attachResolvedThemes(themes, highlighter$1) {
@@ -65,12 +70,12 @@ function attachResolvedThemes(themes, highlighter$1) {
 	for (let themeRef of themes) {
 		let resolvedTheme;
 		if (typeof themeRef === "string") {
-			resolvedTheme = ResolvedThemes.get(themeRef);
+			resolvedTheme = themeResolver.getResolvedTheme(themeRef);
 			if (resolvedTheme == null) throw new Error(`loadResolvedThemes: ${themeRef} is not resolved, you must resolve it before calling loadResolvedThemes`);
 		} else {
 			resolvedTheme = themeRef;
 			themeRef = themeRef.name;
-			if (!ResolvedThemes.has(themeRef)) ResolvedThemes.set(themeRef, resolvedTheme);
+			if (themeResolver.getResolvedTheme(themeRef) == null) themeResolver.seedResolvedTheme(themeRef, resolvedTheme);
 		}
 		if (AttachedThemes.has(themeRef)) continue;
 		AttachedThemes.add(themeRef);
@@ -681,24 +686,27 @@ function getHighlighterThemeStyles({ theme = DEFAULT_THEMES, highlighter: highli
 	let styles = "";
 	if (typeof theme === "string") {
 		const themeData = highlighter$1.getTheme(theme);
-		styles += `color:${themeData.fg};`;
-		styles += `background-color:${themeData.bg};`;
-		styles += `${formatCSSVariablePrefix("global")}fg:${themeData.fg};`;
-		styles += `${formatCSSVariablePrefix("global")}bg:${themeData.bg};`;
-		styles += getThemeVariables(themeData, prefix);
+		const normalized = normalizeThemeColors(themeData);
+		styles += `color:${normalized.fg};`;
+		styles += `background-color:${normalized.bg};`;
+		styles += `${formatCSSVariablePrefix("global")}fg:${normalized.fg};`;
+		styles += `${formatCSSVariablePrefix("global")}bg:${normalized.bg};`;
+		styles += getGitVariables(themeData, prefix);
 	} else {
 		let themeData = highlighter$1.getTheme(theme.dark);
-		styles += `${formatCSSVariablePrefix("global")}dark:${themeData.fg};`;
-		styles += `${formatCSSVariablePrefix("global")}dark-bg:${themeData.bg};`;
-		styles += getThemeVariables(themeData, "dark");
+		let normalized = normalizeThemeColors(themeData);
+		styles += `${formatCSSVariablePrefix("global")}dark:${normalized.fg};`;
+		styles += `${formatCSSVariablePrefix("global")}dark-bg:${normalized.bg};`;
+		styles += getGitVariables(themeData, "dark");
 		themeData = highlighter$1.getTheme(theme.light);
-		styles += `${formatCSSVariablePrefix("global")}light:${themeData.fg};`;
-		styles += `${formatCSSVariablePrefix("global")}light-bg:${themeData.bg};`;
-		styles += getThemeVariables(themeData, "light");
+		normalized = normalizeThemeColors(themeData);
+		styles += `${formatCSSVariablePrefix("global")}light:${normalized.fg};`;
+		styles += `${formatCSSVariablePrefix("global")}light-bg:${normalized.bg};`;
+		styles += getGitVariables(themeData, "light");
 	}
 	return styles;
 }
-function getThemeVariables(themeData, modePrefix) {
+function getGitVariables(themeData, modePrefix) {
 	modePrefix = modePrefix != null ? `${modePrefix}-` : "";
 	let styles = "";
 	const additionGreen = themeData.colors?.["gitDecoration.addedResourceForeground"] ?? themeData.colors?.["terminal.ansiGreen"];
@@ -754,6 +762,39 @@ 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
@@ -766,12 +807,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;
@@ -824,31 +865,24 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			hunkIndex,
 			collapsedContextThreshold
 		});
-		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 trailingRegion = hunkIndex === state.finalHunkIndex ? getTrailingExpandedRegion({
+			fileDiff: diff,
+			hunkIndex,
+			expandedHunks,
+			collapsedContextThreshold,
+			errorPrefix: "iterateOverDiff"
+		}) : void 0;
 		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;
 		}
-		function getPendingCollapsed() {
-			if (leadingRegion.collapsedLines === 0) return 0;
-			const value = leadingRegion.collapsedLines;
-			leadingRegion.collapsedLines = 0;
-			return value;
+		let consumedCollapsed = leadingRegion.collapsedLines === 0;
+		function consumePendingCollapsed() {
+			if (consumedCollapsed) return 0;
+			consumedCollapsed = true;
+			return leadingRegion.collapsedLines;
 		}
 		if (!state.shouldSkip(expandedLineCount, expandedLineCount)) {
 			let unifiedLineIndex$1 = hunk.unifiedLineStart - leadingRegion.rangeSize;
@@ -857,81 +891,63 @@ 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;
-			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++;
-			}
+			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;
 			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;
-			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++;
-			}
+			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;
 		} else {
 			state.incrementCounts(expandedLineCount, expandedLineCount);
-			getPendingCollapsed();
+			consumePendingCollapsed();
 		}
 		let unifiedLineIndex = hunk.unifiedLineStart;
 		let splitLineIndex = hunk.splitLineStart;
@@ -945,45 +961,37 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			const isLastContent = content === lastContent;
 			if (content.type === "context") {
 				if (!state.shouldSkip(content.lines, content.lines)) {
-					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++;
-					}
+					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;
 				} else {
 					state.incrementCounts(content.lines, content.lines);
-					getPendingCollapsed();
+					consumePendingCollapsed();
 				}
 				unifiedLineIndex += content.lines;
 				splitLineIndex += content.lines;
@@ -996,12 +1004,13 @@ 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: getPendingCollapsed(),
+							collapsedBefore: consumePendingCollapsed(),
 							collapsedAfter,
 							diffStyle,
 							index,
@@ -1018,7 +1027,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 						}), true)) break hunkIterator;
 					}
 				}
-				getPendingCollapsed();
+				consumePendingCollapsed();
 				state.incrementCounts(unifiedCount, splitCount);
 				unifiedLineIndex += unifiedCount;
 				splitLineIndex += splitCount;
@@ -1031,41 +1040,30 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 		if (trailingRegion != null) {
 			const { collapsedLines, fromStart, fromEnd } = trailingRegion;
 			const len = fromStart + fromEnd;
-			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++;
-			}
+			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;
 		}
 	}
 }
@@ -1130,15 +1128,14 @@ function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold })
 		const leadingCount = leadingRegion.fromStart + leadingRegion.fromEnd;
 		splitCount += leadingCount + hunk.splitLineCount;
 		unifiedCount += leadingCount + hunk.unifiedLineCount;
-		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 trailingRegion = index === finalHunkIndex ? getTrailingExpandedRegion({
+			fileDiff: diff,
+			hunkIndex: index,
+			expandedHunks,
+			collapsedContextThreshold,
+			errorPrefix: "iterateOverDiff"
+		}) : void 0;
+		if (trailingRegion != null) {
 			const trailingCount = trailingRegion.fromStart + trailingRegion.fromEnd;
 			splitCount += trailingCount;
 			unifiedCount += trailingCount;
@@ -1150,7 +1147,7 @@ function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold })
 	}
 	return prefixCounts;
 }
-function getEqualLineIterationRange(state, count, diffStyle) {
+function getContextLineIterationBounds(state, count, diffStyle) {
 	if (!state.isWindowedHighlight || count <= 0) return [0, count];
 	const ranges = [];
 	function pushRange(currentCount) {
@@ -1170,16 +1167,25 @@ function getEqualLineIterationRange(state, count, diffStyle) {
 	}
 	return [start, end];
 }
-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 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 getChangeIterationRanges(state, content, diffStyle) {
 	if (!state.isWindowedHighlight) return [[0, diffStyle === "unified" ? content.deletions + content.additions : Math.max(content.deletions, content.additions)]];