@pierre/diffs 1.0.7 → 1.1.0-beta.1

package/dist/worker/worker-portable.js

@@ -11680,6 +11680,15 @@ const DEFAULT_THEMES = {
 };
 const UNSAFE_CSS_ATTRIBUTE = "data-unsafe-css";
 const CORE_CSS_ATTRIBUTE = "data-core-css";
+const LINE_HUNK_COUNT = 10;
+const LINE_HEIGHT = 20;
+const DIFF_HEADER_HEIGHT = 44;
+const HUNK_SEPARATOR_HEIGHT = 32;
+const FILE_GAP = 8;
+const DEFAULT_EXPANDED_REGION = Object.freeze({
+	fromStart: 0,
+	fromEnd: 0
+});
 
 //#endregion
 //#region src/highlighter/languages/constants.ts
@@ -13813,18 +13822,28 @@ function findCodeElement(nodes) {
 	}
 	return undefined;
 }
+function createBufferElement(type, height) {
+	return createHastElement({
+		tagName: "div",
+		properties: {
+			"data-virtualized-buffer": type,
+			style: `height: ${height}px`
+		}
+	});
+}
 
 //#endregion
 //#region src/utils/processLine.ts
 function processLine(node, line, state) {
-	const lineInfo = typeof state.lineInfo === "function" ? state.lineInfo(line) : state.lineInfo[line];
+	const lineInfo = typeof state.lineInfo === "function" ? state.lineInfo(line) : state.lineInfo[line - 1];
 	if (lineInfo == null) {
-		console.error({
+		const errorMessage = `processLine: line ${line}, contains no state.lineInfo`;
+		console.error(errorMessage, {
 			node,
 			line,
 			state
 		});
-		throw new Error(`processLine: line ${line}, contains no state.lineInfo`);
+		throw new Error(errorMessage);
 	}
 	node.tagName = "span";
 	node.properties["data-column-content"] = "";
@@ -13858,7 +13877,7 @@ function processLine(node, line, state) {
 //#endregion
 //#region src/utils/createTransformerWithState.ts
 function createTransformerWithState(useCSSClasses = false) {
-	const state = { lineInfo: {} };
+	const state = { lineInfo: [] };
 	const transformers = [{
 		line(node) {
 			delete node.properties.class;
@@ -14334,6 +14353,451 @@ function getLineNodes(nodes) {
 	throw new Error("getLineNodes: Unable to find children");
 }
 
+//#endregion
+//#region src/utils/iterateOverDiff.ts
+function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infinity, expandedHunks, callback }) {
+	const state = {
+		finalHunk: diff.hunks.at(-1),
+		viewportStart: startingLine,
+		viewportEnd: startingLine + totalLines,
+		isWindowedHighlight: startingLine > 0 || totalLines < Infinity,
+		splitCount: 0,
+		unifiedCount: 0,
+		shouldBreak() {
+			if (!state.isWindowedHighlight) {
+				return false;
+			}
+			const breakUnified = state.unifiedCount >= startingLine + totalLines;
+			const breakSplit = state.splitCount >= startingLine + totalLines;
+			if (diffStyle === "unified") {
+				return breakUnified;
+			} else if (diffStyle === "split") {
+				return breakSplit;
+			} else {
+				return breakUnified && breakSplit;
+			}
+		},
+		shouldSkip(unifiedHeight, splitHeight) {
+			if (!state.isWindowedHighlight) {
+				return false;
+			}
+			const skipUnified = state.unifiedCount + unifiedHeight < startingLine;
+			const skipSplit = state.splitCount + splitHeight < startingLine;
+			if (diffStyle === "unified") {
+				return skipUnified;
+			} else if (diffStyle === "split") {
+				return skipSplit;
+			} else {
+				return skipUnified && skipSplit;
+			}
+		},
+		incrementCounts(unifiedValue, splitValue) {
+			if (diffStyle === "unified" || diffStyle === "both") {
+				state.unifiedCount += unifiedValue;
+			}
+			if (diffStyle === "split" || diffStyle === "both") {
+				state.splitCount += splitValue;
+			}
+		},
+		isInWindow(unifiedHeight, splitHeight) {
+			if (!state.isWindowedHighlight) {
+				return true;
+			}
+			const unifiedInWindow = state.isInUnifiedWindow(unifiedHeight);
+			const splitInWindow = state.isInSplitWindow(splitHeight);
+			if (diffStyle === "unified") {
+				return unifiedInWindow;
+			} else if (diffStyle === "split") {
+				return splitInWindow;
+			} else {
+				return unifiedInWindow || splitInWindow;
+			}
+		},
+		isInUnifiedWindow(unifiedHeight) {
+			return !state.isWindowedHighlight || state.unifiedCount >= startingLine - unifiedHeight && state.unifiedCount < startingLine + totalLines;
+		},
+		isInSplitWindow(splitHeight) {
+			return !state.isWindowedHighlight || state.splitCount >= startingLine - splitHeight && state.splitCount < startingLine + totalLines;
+		},
+		emit(props, silent = false) {
+			if (!silent) {
+				if (diffStyle === "unified") {
+					state.incrementCounts(1, 0);
+				} else if (diffStyle === "split") {
+					state.incrementCounts(0, 1);
+				} else {
+					state.incrementCounts(1, 1);
+				}
+			}
+			return callback(props) ?? false;
+		}
+	};
+	hunkIterator: for (const [hunkIndex, hunk] of diff.hunks.entries()) {
+		if (state.shouldBreak()) {
+			break;
+		}
+		const leadingRegion = getExpandedRegion(diff.isPartial, hunk.collapsedBefore, expandedHunks, hunkIndex);
+		const trailingRegion = (() => {
+			if (hunk !== state.finalHunk || !hasFinalCollapsedHunk(diff)) {
+				return undefined;
+			}
+			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(diff.isPartial, trailingRangeSize, expandedHunks, diff.hunks.length);
+		})();
+		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;
+		}
+		if (!state.shouldSkip(expandedLineCount, expandedLineCount)) {
+			let unifiedLineIndex$1 = hunk.unifiedLineStart - leadingRegion.rangeSize;
+			let splitLineIndex$1 = hunk.splitLineStart - leadingRegion.rangeSize;
+			let deletionLineIndex$1 = hunk.deletionLineIndex - leadingRegion.rangeSize;
+			let additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.rangeSize;
+			let deletionLineNumber$1 = hunk.deletionStart - leadingRegion.rangeSize;
+			let additionLineNumber$1 = hunk.additionStart - leadingRegion.rangeSize;
+			let index = 0;
+			while (index < leadingRegion.fromStart) {
+				if (state.isInWindow(0, 0)) {
+					if (state.emit({
+						hunkIndex,
+						hunk,
+						collapsedBefore: 0,
+						collapsedAfter: 0,
+						unifiedDeletionLineIndex: unifiedLineIndex$1 + index,
+						unifiedAdditionLineIndex: unifiedLineIndex$1 + index,
+						splitLineIndex: splitLineIndex$1 + index,
+						deletionLineIndex: deletionLineIndex$1 + index,
+						additionLineIndex: additionLineIndex$1 + index,
+						deletionLineNumber: deletionLineNumber$1 + index,
+						additionLineNumber: additionLineNumber$1 + index,
+						type: "context-expanded",
+						noEOFCRAddition: false,
+						noEOFCRDeletion: 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;
+			index = 0;
+			while (index < leadingRegion.fromEnd) {
+				if (state.isInWindow(0, 0)) {
+					if (state.emit({
+						hunkIndex,
+						hunk,
+						collapsedBefore: getPendingCollapsed(),
+						collapsedAfter: 0,
+						unifiedDeletionLineIndex: unifiedLineIndex$1 + index,
+						unifiedAdditionLineIndex: unifiedLineIndex$1 + index,
+						splitLineIndex: splitLineIndex$1 + index,
+						deletionLineIndex: deletionLineIndex$1 + index,
+						additionLineIndex: additionLineIndex$1 + index,
+						deletionLineNumber: deletionLineNumber$1 + index,
+						additionLineNumber: additionLineNumber$1 + index,
+						type: "context-expanded",
+						noEOFCRAddition: false,
+						noEOFCRDeletion: false
+					})) {
+						break hunkIterator;
+					}
+				} else {
+					state.incrementCounts(1, 1);
+				}
+				index++;
+			}
+		} else {
+			state.incrementCounts(expandedLineCount, expandedLineCount);
+			getPendingCollapsed();
+		}
+		let unifiedLineIndex = hunk.unifiedLineStart;
+		let splitLineIndex = hunk.splitLineStart;
+		let deletionLineIndex = hunk.deletionLineIndex;
+		let additionLineIndex = hunk.additionLineIndex;
+		let deletionLineNumber = hunk.deletionStart;
+		let additionLineNumber = hunk.additionStart;
+		const lastContent = hunk.hunkContent.at(-1);
+		for (const content of hunk.hunkContent) {
+			if (state.shouldBreak()) {
+				break hunkIterator;
+			}
+			const isLastContent = content === lastContent;
+			if (content.type === "context") {
+				if (!state.shouldSkip(content.lines, content.lines)) {
+					let index = 0;
+					while (index < content.lines) {
+						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),
+								unifiedDeletionLineIndex: unifiedRowIndex,
+								unifiedAdditionLineIndex: unifiedRowIndex,
+								splitLineIndex: splitRowIndex,
+								deletionLineIndex: deletionLineIndex + index,
+								additionLineIndex: additionLineIndex + index,
+								deletionLineNumber: deletionLineNumber + index,
+								additionLineNumber: additionLineNumber + index,
+								type: "context",
+								noEOFCRAddition: isLastLine && hunk.noEOFCRAdditions,
+								noEOFCRDeletion: isLastLine && hunk.noEOFCRDeletions
+							})) {
+								break hunkIterator;
+							}
+						} else {
+							state.incrementCounts(1, 1);
+						}
+						index++;
+					}
+				} else {
+					state.incrementCounts(content.lines, content.lines);
+					getPendingCollapsed();
+				}
+				unifiedLineIndex += content.lines;
+				splitLineIndex += content.lines;
+				deletionLineIndex += content.lines;
+				additionLineIndex += content.lines;
+				deletionLineNumber += content.lines;
+				additionLineNumber += content.lines;
+			} else {
+				const splitCount = Math.max(content.deletions, content.additions);
+				const unifiedCount = content.deletions + content.additions;
+				const shouldSkipChange = state.shouldSkip(unifiedCount, splitCount);
+				if (!shouldSkipChange) {
+					const iterationRanges = getChangeIterationRanges(state, content, diffStyle);
+					for (const [rangeStart, rangeEnd] of iterationRanges) {
+						for (let index = rangeStart; index < rangeEnd; index++) {
+							const unifiedRowIndex = unifiedLineIndex + index;
+							const splitRowIndex = diffStyle === "unified" ? splitLineIndex + (index < content.deletions ? index : index - content.deletions) : splitLineIndex + index;
+							const collapsedAfter = getTrailingCollapsedAfter(unifiedRowIndex, splitRowIndex);
+							if (state.emit(getChangeLineData({
+								hunkIndex,
+								hunk,
+								collapsedBefore: getPendingCollapsed(),
+								collapsedAfter,
+								diffStyle,
+								index,
+								unifiedLineIndex,
+								splitLineIndex,
+								additionLineIndex,
+								deletionLineIndex,
+								additionLineNumber,
+								deletionLineNumber,
+								content,
+								isLastContent,
+								unifiedCount,
+								splitCount
+							}), true)) {
+								break hunkIterator;
+							}
+						}
+					}
+				}
+				getPendingCollapsed();
+				state.incrementCounts(unifiedCount, splitCount);
+				unifiedLineIndex += unifiedCount;
+				splitLineIndex += splitCount;
+				deletionLineIndex += content.deletions;
+				additionLineIndex += content.additions;
+				deletionLineNumber += content.deletions;
+				additionLineNumber += content.additions;
+			}
+		}
+		if (trailingRegion != null) {
+			const { collapsedLines, fromStart, fromEnd } = trailingRegion;
+			const len = fromStart + fromEnd;
+			let index = 0;
+			while (index < len) {
+				if (state.shouldBreak()) {
+					break hunkIterator;
+				}
+				if (state.isInWindow(0, 0)) {
+					const isLastLine = index === len - 1;
+					if (state.emit({
+						hunkIndex: diff.hunks.length,
+						hunk: undefined,
+						collapsedBefore: 0,
+						collapsedAfter: isLastLine ? collapsedLines : 0,
+						unifiedDeletionLineIndex: unifiedLineIndex + index,
+						unifiedAdditionLineIndex: unifiedLineIndex + index,
+						splitLineIndex: splitLineIndex + index,
+						additionLineIndex: additionLineIndex + index,
+						deletionLineIndex: deletionLineIndex + index,
+						additionLineNumber: additionLineNumber + index,
+						deletionLineNumber: deletionLineNumber + index,
+						type: "context-expanded",
+						noEOFCRAddition: false,
+						noEOFCRDeletion: false
+					})) {
+						break hunkIterator;
+					}
+				} else {
+					state.incrementCounts(1, 1);
+				}
+				index++;
+			}
+		}
+	}
+}
+function getExpandedRegion(isPartial, rangeSize, expandedHunks, hunkIndex) {
+	rangeSize = Math.max(rangeSize, 0);
+	if (rangeSize === 0 || isPartial) {
+		return {
+			fromStart: 0,
+			fromEnd: 0,
+			rangeSize,
+			collapsedLines: Math.max(rangeSize, 0)
+		};
+	}
+	if (expandedHunks === true) {
+		return {
+			fromStart: rangeSize,
+			fromEnd: 0,
+			rangeSize,
+			collapsedLines: 0
+		};
+	}
+	const region = expandedHunks?.get(hunkIndex);
+	const fromStart = Math.min(Math.max(region?.fromStart ?? 0, 0), rangeSize);
+	const fromEnd = Math.min(Math.max(region?.fromEnd ?? 0, 0), rangeSize);
+	const expandedCount = fromStart + fromEnd;
+	const renderAll = expandedCount >= rangeSize;
+	return {
+		fromStart: renderAll ? rangeSize : fromStart,
+		fromEnd: renderAll ? 0 : fromEnd,
+		rangeSize,
+		collapsedLines: Math.max(rangeSize - expandedCount, 0)
+	};
+}
+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)]];
+	}
+	const useUnified = diffStyle !== "split";
+	const useSplit = diffStyle !== "unified";
+	const iterationSpace = diffStyle === "unified" ? "unified" : "split";
+	const iterationRanges = [];
+	function getVisibleRange(start, count) {
+		const end = start + count;
+		if (end <= state.viewportStart || start >= state.viewportEnd) {
+			return undefined;
+		}
+		const visibleStart = Math.max(0, state.viewportStart - start);
+		const visibleEnd = Math.min(count, state.viewportEnd - start);
+		return visibleEnd > visibleStart ? [visibleStart, visibleEnd] : undefined;
+	}
+	function mapRangeToIteration(range$1, kind) {
+		if (iterationSpace === "split") {
+			return range$1;
+		}
+		return kind === "additions" ? [range$1[0] + content.deletions, range$1[1] + content.deletions] : range$1;
+	}
+	function pushRange(range$1, kind) {
+		if (range$1 == null) {
+			return;
+		}
+		const [start, end] = mapRangeToIteration(range$1, kind);
+		if (end > start) {
+			iterationRanges.push([start, end]);
+		}
+	}
+	if (useUnified) {
+		pushRange(getVisibleRange(state.unifiedCount, content.deletions), "deletions");
+		pushRange(getVisibleRange(state.unifiedCount + content.deletions, content.additions), "additions");
+	}
+	if (useSplit) {
+		pushRange(getVisibleRange(state.splitCount, content.deletions), "deletions");
+		pushRange(getVisibleRange(state.splitCount, content.additions), "additions");
+	}
+	if (iterationRanges.length === 0) {
+		return iterationRanges;
+	}
+	iterationRanges.sort((a$1, b$2) => a$1[0] - b$2[0]);
+	const merged = [iterationRanges[0]];
+	for (const [start, end] of iterationRanges.slice(1)) {
+		const last = merged[merged.length - 1];
+		if (start <= last[1]) {
+			last[1] = Math.max(last[1], end);
+		} else {
+			merged.push([start, end]);
+		}
+	}
+	return merged;
+}
+function getChangeLineData({ hunkIndex, hunk, collapsedAfter, collapsedBefore, diffStyle, index, unifiedLineIndex, splitLineIndex, additionLineIndex, deletionLineIndex, additionLineNumber, deletionLineNumber, content, isLastContent, unifiedCount, splitCount }) {
+	if (diffStyle === "unified") {
+		return {
+			type: "change",
+			hunkIndex,
+			hunk,
+			collapsedAfter,
+			collapsedBefore,
+			unifiedDeletionLineIndex: index < content.deletions ? unifiedLineIndex + index : undefined,
+			unifiedAdditionLineIndex: index >= content.deletions ? unifiedLineIndex + index : undefined,
+			splitLineIndex: splitLineIndex + (index < content.deletions ? index : index - content.deletions),
+			additionLineIndex: index >= content.deletions ? additionLineIndex + (index - content.deletions) : undefined,
+			additionLineNumber: index >= content.deletions ? additionLineNumber + (index - content.deletions) : undefined,
+			deletionLineIndex: index < content.deletions ? deletionLineIndex + index : undefined,
+			deletionLineNumber: index < content.deletions ? deletionLineNumber + index : undefined,
+			noEOFCRDeletion: isLastContent && index === content.deletions - 1 && hunk.noEOFCRDeletions,
+			noEOFCRAddition: isLastContent && index === unifiedCount - 1 && hunk.noEOFCRAdditions
+		};
+	}
+	return {
+		type: "change",
+		hunkIndex,
+		hunk,
+		collapsedAfter,
+		collapsedBefore,
+		unifiedDeletionLineIndex: index < content.deletions ? unifiedLineIndex + index : undefined,
+		unifiedAdditionLineIndex: index < content.additions ? unifiedLineIndex + content.deletions + index : undefined,
+		splitLineIndex: splitLineIndex + index,
+		additionLineIndex: index < content.additions ? additionLineIndex + index : undefined,
+		additionLineNumber: index < content.additions ? additionLineNumber + index : undefined,
+		deletionLineIndex: index < content.deletions ? deletionLineIndex + index : undefined,
+		deletionLineNumber: index < content.deletions ? deletionLineNumber + index : undefined,
+		noEOFCRDeletion: isLastContent && index === splitCount - 1 && hunk.noEOFCRDeletions,
+		noEOFCRAddition: isLastContent && index === splitCount - 1 && hunk.noEOFCRAdditions
+	};
+}
+
 //#endregion
 //#region src/utils/parseDiffDecorations.ts
 function createDiffSpanDecoration({ line, spanStart, spanLength }) {
@@ -14366,7 +14830,16 @@ function pushOrJoinSpan({ item, arr, enableJoin, isNeutral = false, isLastItem =
 
 //#endregion
 //#region src/utils/renderDiffWithHighlighter.ts
-function renderDiffWithHighlighter(diff, highlighter$1, options, forcePlainText = false) {
+const DEFAULT_PLAIN_TEXT_OPTIONS = { forcePlainText: false };
+function renderDiffWithHighlighter(diff, highlighter$1, options, { forcePlainText, startingLine, totalLines, expandedHunks } = DEFAULT_PLAIN_TEXT_OPTIONS) {
+	if (forcePlainText) {
+		startingLine ??= 0;
+		totalLines ??= Infinity;
+	} else {
+		startingLine = 0;
+		totalLines = Infinity;
+	}
+	const isWindowedHighlight = startingLine > 0 || totalLines < Infinity;
 	const baseThemeType = (() => {
 		const theme = options.theme ?? DEFAULT_THEMES;
 		if (typeof theme === "string") {
@@ -14378,100 +14851,140 @@ function renderDiffWithHighlighter(diff, highlighter$1, options, forcePlainText
 		theme: options.theme,
 		highlighter: highlighter$1
 	});
-	if (diff.newLines != null && diff.oldLines != null) {
-		const { oldContent, newContent, oldInfo, newInfo, oldDecorations, newDecorations } = processLines({
-			hunks: diff.hunks,
-			oldLines: diff.oldLines,
-			newLines: diff.newLines,
-			lineDiffType: options.lineDiffType
-		});
-		const oldFile = {
+	const lineDiffType = forcePlainText && !isWindowedHighlight && (diff.unifiedLineCount > 1e3 || diff.splitLineCount > 1e3) ? "none" : options.lineDiffType;
+	const code = {
+		deletionLines: [],
+		additionLines: []
+	};
+	const shouldGroupAll = !forcePlainText && !diff.isPartial;
+	const expandedHunksForIteration = forcePlainText ? expandedHunks : undefined;
+	const buckets = new Map();
+	function getBucketForHunk(hunkIndex) {
+		const index = shouldGroupAll ? 0 : hunkIndex;
+		const bucket = buckets.get(index) ?? createBucket();
+		buckets.set(index, bucket);
+		return bucket;
+	}
+	function appendContent(lineContent, lineIndex, segments, contentWrapper) {
+		if (isWindowedHighlight) {
+			let segment = segments.at(-1);
+			if (segment == null || segment.targetIndex + segment.count !== lineIndex) {
+				segment = {
+					targetIndex: lineIndex,
+					originalOffset: contentWrapper.length,
+					count: 0
+				};
+				segments.push(segment);
+			}
+			segment.count++;
+		}
+		contentWrapper.push(lineContent);
+	}
+	iterateOverDiff({
+		diff,
+		diffStyle: "both",
+		startingLine,
+		totalLines,
+		expandedHunks: isWindowedHighlight ? expandedHunksForIteration : true,
+		callback: ({ hunkIndex, additionLineIndex, deletionLineIndex, additionLineNumber, deletionLineNumber, unifiedAdditionLineIndex, unifiedDeletionLineIndex, splitLineIndex, type }) => {
+			const bucket = getBucketForHunk(hunkIndex);
+			if (type === "change" && lineDiffType !== "none" && additionLineIndex != null && deletionLineIndex != null) {
+				computeLineDiffDecorations({
+					additionLine: diff.additionLines[additionLineIndex],
+					deletionLine: diff.deletionLines[deletionLineIndex],
+					deletionLineIndex: bucket.deletionContent.length,
+					additionLineIndex: bucket.additionContent.length,
+					deletionDecorations: bucket.deletionDecorations,
+					additionDecorations: bucket.additionDecorations,
+					lineDiffType
+				});
+			}
+			if (deletionLineIndex != null && deletionLineNumber != null && unifiedDeletionLineIndex != null) {
+				appendContent(diff.deletionLines[deletionLineIndex], deletionLineIndex, bucket.deletionSegments, bucket.deletionContent);
+				bucket.deletionInfo.push({
+					type: type === "change" ? "change-deletion" : type,
+					lineNumber: deletionLineNumber,
+					altLineNumber: type === "change" ? undefined : additionLineNumber ?? undefined,
+					lineIndex: `${unifiedDeletionLineIndex},${splitLineIndex}`
+				});
+			}
+			if (additionLineIndex != null && additionLineNumber != null && unifiedAdditionLineIndex != null) {
+				appendContent(diff.additionLines[additionLineIndex], additionLineIndex, bucket.additionSegments, bucket.additionContent);
+				bucket.additionInfo.push({
+					type: type === "change" ? "change-addition" : type,
+					lineNumber: additionLineNumber,
+					altLineNumber: type === "change" ? undefined : deletionLineNumber ?? undefined,
+					lineIndex: `${unifiedAdditionLineIndex},${splitLineIndex}`
+				});
+			}
+		}
+	});
+	for (const bucket of buckets.values()) {
+		if (bucket.deletionContent.length === 0 && bucket.additionContent.length === 0) {
+			continue;
+		}
+		const deletionFile = {
 			name: diff.prevName ?? diff.name,
-			contents: oldContent
+			contents: bucket.deletionContent.value
 		};
-		const newFile = {
+		const additionFile = {
 			name: diff.name,
-			contents: newContent
+			contents: bucket.additionContent.value
 		};
-		const code$1 = renderTwoFiles({
-			oldFile,
-			oldInfo,
-			oldDecorations,
-			newFile,
-			newInfo,
-			newDecorations,
+		const { deletionLines, additionLines } = renderTwoFiles({
+			deletionFile,
+			deletionInfo: bucket.deletionInfo,
+			deletionDecorations: bucket.deletionDecorations,
+			additionFile,
+			additionInfo: bucket.additionInfo,
+			additionDecorations: bucket.additionDecorations,
 			highlighter: highlighter$1,
 			options,
 			languageOverride: forcePlainText ? "text" : diff.lang
 		});
-		return {
-			code: code$1,
-			themeStyles,
-			baseThemeType
-		};
-	}
-	const hunks = [];
-	let splitLineIndex = 0;
-	let unifiedLineIndex = 0;
-	for (const hunk of diff.hunks) {
-		const { oldContent, newContent, oldInfo, newInfo, oldDecorations, newDecorations, splitLineIndex: newSplitLineIndex, unifiedLineIndex: newUnifiedLineIndex } = processLines({
-			hunks: [hunk],
-			splitLineIndex,
-			unifiedLineIndex,
-			lineDiffType: options.lineDiffType
-		});
-		const oldFile = {
-			name: diff.prevName ?? diff.name,
-			contents: oldContent
-		};
-		const newFile = {
-			name: diff.name,
-			contents: newContent
-		};
-		hunks.push(renderTwoFiles({
-			oldFile,
-			oldInfo,
-			oldDecorations,
-			newFile,
-			newInfo,
-			newDecorations,
-			highlighter: highlighter$1,
-			options,
-			languageOverride: forcePlainText ? "text" : diff.lang
-		}));
-		splitLineIndex = newSplitLineIndex;
-		unifiedLineIndex = newUnifiedLineIndex;
-	}
-	const code = (() => {
-		if (hunks.length <= 1) {
-			const hunk = hunks[0] ?? {
-				oldLines: [],
-				newLines: []
-			};
-			if (hunk.newLines.length === 0 || hunk.oldLines.length === 0) {
-				return hunk;
+		if (shouldGroupAll) {
+			code.deletionLines = deletionLines;
+			code.additionLines = additionLines;
+			continue;
+		}
+		if (bucket.deletionSegments.length > 0) {
+			for (const seg of bucket.deletionSegments) {
+				for (let i$2 = 0; i$2 < seg.count; i$2++) {
+					code.deletionLines[seg.targetIndex + i$2] = deletionLines[seg.originalOffset + i$2];
+				}
 			}
+		} else {
+			code.deletionLines.push(...deletionLines);
 		}
-		return { hunks };
-	})();
+		if (bucket.additionSegments.length > 0) {
+			for (const seg of bucket.additionSegments) {
+				for (let i$2 = 0; i$2 < seg.count; i$2++) {
+					code.additionLines[seg.targetIndex + i$2] = additionLines[seg.originalOffset + i$2];
+				}
+			}
+		} else {
+			code.additionLines.push(...additionLines);
+		}
+	}
 	return {
 		code,
 		themeStyles,
 		baseThemeType
 	};
 }
-function computeLineDiffDecorations({ oldLine, newLine, oldLineIndex, newLineIndex, oldDecorations, newDecorations, lineDiffType }) {
-	if (oldLine == null || newLine == null || lineDiffType === "none") {
+function computeLineDiffDecorations({ deletionLine, additionLine, deletionLineIndex, additionLineIndex, deletionDecorations, additionDecorations, lineDiffType }) {
+	if (deletionLine == null || additionLine == null || lineDiffType === "none") {
 		return;
 	}
-	oldLine = cleanLastNewline(oldLine);
-	newLine = cleanLastNewline(newLine);
-	const lineDiff$1 = lineDiffType === "char" ? diffChars(oldLine, newLine) : diffWordsWithSpace(oldLine, newLine);
+	deletionLine = cleanLastNewline(deletionLine);
+	additionLine = cleanLastNewline(additionLine);
+	const lineDiff$1 = lineDiffType === "char" ? diffChars(deletionLine, additionLine) : diffWordsWithSpace(deletionLine, additionLine);
 	const deletionSpans = [];
 	const additionSpans = [];
 	const enableJoin = lineDiffType === "word-alt";
+	const lastItem = lineDiff$1.at(-1);
 	for (const item of lineDiff$1) {
-		const isLastItem = item === lineDiff$1[lineDiff$1.length - 1];
+		const isLastItem = item === lastItem;
 		if (!item.added && !item.removed) {
 			pushOrJoinSpan({
 				item,
@@ -14506,8 +15019,8 @@ function computeLineDiffDecorations({ oldLine, newLine, oldLineIndex, newLineInd
 	let spanIndex = 0;
 	for (const span of deletionSpans) {
 		if (span[0] === 1) {
-			oldDecorations.push(createDiffSpanDecoration({
-				line: oldLineIndex - 1,
+			deletionDecorations.push(createDiffSpanDecoration({
+				line: deletionLineIndex,
 				spanStart: spanIndex,
 				spanLength: span[1].length
 			}));
@@ -14517,8 +15030,8 @@ function computeLineDiffDecorations({ oldLine, newLine, oldLineIndex, newLineInd
 	spanIndex = 0;
 	for (const span of additionSpans) {
 		if (span[0] === 1) {
-			newDecorations.push(createDiffSpanDecoration({
-				line: newLineIndex - 1,
+			additionDecorations.push(createDiffSpanDecoration({
+				line: additionLineIndex,
 				spanStart: spanIndex,
 				spanLength: span[1].length
 			}));
@@ -14526,156 +15039,35 @@ function computeLineDiffDecorations({ oldLine, newLine, oldLineIndex, newLineInd
 		spanIndex += span[1].length;
 	}
 }
-function processLines({ hunks, oldLines, newLines, splitLineIndex = 0, unifiedLineIndex = 0, lineDiffType }) {
-	const oldInfo = {};
-	const newInfo = {};
-	const oldDecorations = [];
-	const newDecorations = [];
-	let newLineIndex = 1;
-	let oldLineIndex = 1;
-	let newLineNumber = 1;
-	let oldLineNumber = 1;
-	let oldContent = "";
-	let newContent = "";
-	for (const hunk of hunks) {
-		while (oldLines != null && newLines != null && newLineIndex < hunk.additionStart && oldLineIndex < hunk.deletionStart) {
-			oldInfo[oldLineIndex] = {
-				type: "context-expanded",
-				lineNumber: oldLineNumber,
-				altLineNumber: newLineNumber,
-				lineIndex: `${unifiedLineIndex},${splitLineIndex}`
-			};
-			newInfo[newLineIndex] = {
-				type: "context-expanded",
-				lineNumber: newLineNumber,
-				altLineNumber: oldLineNumber,
-				lineIndex: `${unifiedLineIndex},${splitLineIndex}`
-			};
-			oldContent += oldLines[oldLineIndex - 1];
-			newContent += newLines[newLineIndex - 1];
-			oldLineIndex++;
-			newLineIndex++;
-			oldLineNumber++;
-			newLineNumber++;
-			splitLineIndex++;
-			unifiedLineIndex++;
-		}
-		oldLineNumber = hunk.deletionStart;
-		newLineNumber = hunk.additionStart;
-		for (const hunkContent of hunk.hunkContent) {
-			if (hunkContent.type === "context") {
-				for (const line of hunkContent.lines) {
-					oldInfo[oldLineIndex] = {
-						type: "context",
-						lineNumber: oldLineNumber,
-						altLineNumber: newLineNumber,
-						lineIndex: `${unifiedLineIndex},${splitLineIndex}`
-					};
-					newInfo[newLineIndex] = {
-						type: "context",
-						lineNumber: newLineNumber,
-						altLineNumber: oldLineNumber,
-						lineIndex: `${unifiedLineIndex},${splitLineIndex}`
-					};
-					oldContent += line;
-					newContent += line;
-					oldLineIndex++;
-					newLineIndex++;
-					newLineNumber++;
-					oldLineNumber++;
-					splitLineIndex++;
-					unifiedLineIndex++;
-				}
-			} else {
-				const len = Math.max(hunkContent.additions.length, hunkContent.deletions.length);
-				let i$2 = 0;
-				let _unifiedLineIndex = unifiedLineIndex;
-				while (i$2 < len) {
-					const oldLine = hunkContent.deletions[i$2];
-					const newLine = hunkContent.additions[i$2];
-					computeLineDiffDecorations({
-						newLine,
-						oldLine,
-						oldLineIndex,
-						newLineIndex,
-						oldDecorations,
-						newDecorations,
-						lineDiffType
-					});
-					if (oldLine != null) {
-						oldInfo[oldLineIndex] = {
-							type: "change-deletion",
-							lineNumber: oldLineNumber,
-							lineIndex: `${_unifiedLineIndex},${splitLineIndex}`
-						};
-						oldContent += oldLine;
-						oldLineIndex++;
-						oldLineNumber++;
-					}
-					if (newLine != null) {
-						newInfo[newLineIndex] = {
-							type: "change-addition",
-							lineNumber: newLineNumber,
-							lineIndex: `${_unifiedLineIndex + hunkContent.deletions.length},${splitLineIndex}`
-						};
-						newContent += newLine;
-						newLineIndex++;
-						newLineNumber++;
-					}
-					splitLineIndex++;
-					_unifiedLineIndex++;
-					i$2++;
-				}
-				unifiedLineIndex += hunkContent.additions.length + hunkContent.deletions.length;
-			}
-		}
-		if (oldLines == null || newLines == null || hunk !== hunks[hunks.length - 1]) continue;
-		while (oldLineIndex <= oldLines.length || newLineIndex <= oldLines.length) {
-			const oldLine = oldLines[oldLineIndex - 1];
-			const newLine = newLines[newLineIndex - 1];
-			if (oldLine == null && newLine == null) {
-				break;
-			}
-			if (oldLine != null) {
-				oldInfo[oldLineIndex] = {
-					type: "context-expanded",
-					lineNumber: oldLineNumber,
-					altLineNumber: newLineNumber,
-					lineIndex: `${unifiedLineIndex},${splitLineIndex}`
-				};
-				oldContent += oldLine;
-				oldLineIndex++;
-				oldLineNumber++;
-			}
-			if (newLine != null) {
-				newInfo[newLineIndex] = {
-					type: "context-expanded",
-					lineNumber: newLineNumber,
-					altLineNumber: oldLineNumber,
-					lineIndex: `${unifiedLineIndex},${splitLineIndex}`
-				};
-				newContent += newLine;
-				newLineIndex++;
-				newLineNumber++;
-			}
-			splitLineIndex++;
-			unifiedLineIndex++;
-		}
-	}
+function createBucket() {
 	return {
-		oldContent,
-		newContent,
-		oldInfo,
-		newInfo,
-		oldDecorations,
-		newDecorations,
-		splitLineIndex,
-		unifiedLineIndex
+		deletionContent: {
+			push(value) {
+				this.value += value;
+				this.length++;
+			},
+			value: "",
+			length: 0
+		},
+		additionContent: {
+			push(value) {
+				this.value += value;
+				this.length++;
+			},
+			value: "",
+			length: 0
+		},
+		deletionInfo: [],
+		additionInfo: [],
+		deletionDecorations: [],
+		additionDecorations: [],
+		deletionSegments: [],
+		additionSegments: []
 	};
 }
-function renderTwoFiles({ oldFile, newFile, oldInfo, newInfo, highlighter: highlighter$1, oldDecorations, newDecorations, languageOverride, options: { theme: themeOrThemes = DEFAULT_THEMES,...options } }) {
-	const oldLang = languageOverride ?? getFiletypeFromFileName(oldFile.name);
-	const newLang = languageOverride ?? getFiletypeFromFileName(newFile.name);
+function renderTwoFiles({ deletionFile, additionFile, deletionInfo, additionInfo, highlighter: highlighter$1, deletionDecorations, additionDecorations, languageOverride, options: { theme: themeOrThemes = DEFAULT_THEMES,...options } }) {
+	const deletionLang = languageOverride ?? getFiletypeFromFileName(deletionFile.name);
+	const additionLang = languageOverride ?? getFiletypeFromFileName(additionFile.name);
 	const { state, transformers } = createTransformerWithState();
 	const hastConfig = (() => {
 		return typeof themeOrThemes === "string" ? {
@@ -14696,27 +15088,27 @@ function renderTwoFiles({ oldFile, newFile, oldInfo, newInfo, highlighter: highl
 			cssVariablePrefix: formatCSSVariablePrefix("token")
 		};
 	})();
-	const oldLines = (() => {
-		if (oldFile.contents === "") {
+	const deletionLines = (() => {
+		if (deletionFile.contents === "") {
 			return [];
 		}
-		hastConfig.lang = oldLang;
-		state.lineInfo = oldInfo;
-		hastConfig.decorations = oldDecorations;
-		return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(oldFile.contents), hastConfig));
+		hastConfig.lang = deletionLang;
+		state.lineInfo = deletionInfo;
+		hastConfig.decorations = deletionDecorations;
+		return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(deletionFile.contents), hastConfig));
 	})();
-	const newLines = (() => {
-		if (newFile.contents === "") {
+	const additionLines = (() => {
+		if (additionFile.contents === "") {
 			return [];
 		}
-		hastConfig.lang = newLang;
-		hastConfig.decorations = newDecorations;
-		state.lineInfo = newInfo;
-		return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(newFile.contents), hastConfig));
+		hastConfig.lang = additionLang;
+		hastConfig.decorations = additionDecorations;
+		state.lineInfo = additionInfo;
+		return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(additionFile.contents), hastConfig));
 	})();
 	return {
-		oldLines,
-		newLines
+		deletionLines,
+		additionLines
 	};
 }