@pierre/diffs 1.0.7 → 1.1.0-beta.1

package/dist/worker/worker.js

@@ -8,6 +8,10 @@ const DEFAULT_THEMES = {
 	dark: "pierre-dark",
 	light: "pierre-light"
 };
+const DEFAULT_EXPANDED_REGION = Object.freeze({
+	fromStart: 0,
+	fromEnd: 0
+});
 
 //#endregion
 //#region src/highlighter/languages/constants.ts
@@ -89,14 +93,15 @@ function findCodeElement(nodes) {
 //#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"] = "";
@@ -127,7 +132,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;
@@ -566,6 +571,360 @@ 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;
+			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;
+				if (!state.shouldSkip(unifiedCount, splitCount)) {
+					const iterationRanges = getChangeIterationRanges(state, content, diffStyle);
+					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(),
+							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: void 0,
+						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) {
+		if (start + count <= state.viewportStart || start >= state.viewportEnd) return;
+		const visibleStart = Math.max(0, state.viewportStart - start);
+		const visibleEnd = Math.min(count, state.viewportEnd - start);
+		return visibleEnd > visibleStart ? [visibleStart, visibleEnd] : void 0;
+	}
+	function mapRangeToIteration(range, kind) {
+		if (iterationSpace === "split") return range;
+		return kind === "additions" ? [range[0] + content.deletions, range[1] + content.deletions] : range;
+	}
+	function pushRange(range, kind) {
+		if (range == null) return;
+		const [start, end] = mapRangeToIteration(range, 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, b) => a[0] - b[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 : void 0,
+		unifiedAdditionLineIndex: index >= content.deletions ? unifiedLineIndex + index : void 0,
+		splitLineIndex: splitLineIndex + (index < content.deletions ? index : index - content.deletions),
+		additionLineIndex: index >= content.deletions ? additionLineIndex + (index - content.deletions) : void 0,
+		additionLineNumber: index >= content.deletions ? additionLineNumber + (index - content.deletions) : void 0,
+		deletionLineIndex: index < content.deletions ? deletionLineIndex + index : void 0,
+		deletionLineNumber: index < content.deletions ? deletionLineNumber + index : void 0,
+		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 : void 0,
+		unifiedAdditionLineIndex: index < content.additions ? unifiedLineIndex + content.deletions + index : void 0,
+		splitLineIndex: splitLineIndex + index,
+		additionLineIndex: index < content.additions ? additionLineIndex + index : void 0,
+		additionLineNumber: index < content.additions ? additionLineNumber + index : void 0,
+		deletionLineIndex: index < content.deletions ? deletionLineIndex + index : void 0,
+		deletionLineNumber: index < content.deletions ? deletionLineNumber + index : void 0,
+		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 }) {
@@ -598,7 +957,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") return highlighter$1.getTheme(theme).type;
@@ -607,92 +975,120 @@ 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
-		});
-		return {
-			code: renderTwoFiles({
-				oldFile: {
-					name: diff.prevName ?? diff.name,
-					contents: oldContent
-				},
-				oldInfo,
-				oldDecorations,
-				newFile: {
-					name: diff.name,
-					contents: newContent
-				},
-				newInfo,
-				newDecorations,
-				highlighter: highlighter$1,
-				options,
-				languageOverride: forcePlainText ? "text" : diff.lang
-			}),
-			themeStyles,
-			baseThemeType
-		};
+	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 : void 0;
+	const buckets = /* @__PURE__ */ new Map();
+	function getBucketForHunk(hunkIndex) {
+		const index = shouldGroupAll ? 0 : hunkIndex;
+		const bucket = buckets.get(index) ?? createBucket();
+		buckets.set(index, bucket);
+		return bucket;
 	}
-	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 = {
+	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" ? void 0 : additionLineNumber ?? void 0,
+					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" ? void 0 : deletionLineNumber ?? void 0,
+					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
 		};
-		hunks.push(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
-		}));
-		splitLineIndex = newSplitLineIndex;
-		unifiedLineIndex = newUnifiedLineIndex;
+		});
+		if (shouldGroupAll) {
+			code.deletionLines = deletionLines;
+			code.additionLines = additionLines;
+			continue;
+		}
+		if (bucket.deletionSegments.length > 0) for (const seg of bucket.deletionSegments) for (let i = 0; i < seg.count; i++) code.deletionLines[seg.targetIndex + i] = deletionLines[seg.originalOffset + i];
+		else code.deletionLines.push(...deletionLines);
+		if (bucket.additionSegments.length > 0) for (const seg of bucket.additionSegments) for (let i = 0; i < seg.count; i++) code.additionLines[seg.targetIndex + i] = additionLines[seg.originalOffset + i];
+		else code.additionLines.push(...additionLines);
 	}
 	return {
-		code: (() => {
-			if (hunks.length <= 1) {
-				const hunk = hunks[0] ?? {
-					oldLines: [],
-					newLines: []
-				};
-				if (hunk.newLines.length === 0 || hunk.oldLines.length === 0) return hunk;
-			}
-			return { hunks };
-		})(),
+		code,
 		themeStyles,
 		baseThemeType
 	};
 }
-function computeLineDiffDecorations({ oldLine, newLine, oldLineIndex, newLineIndex, oldDecorations, newDecorations, lineDiffType }) {
-	if (oldLine == null || newLine == null || lineDiffType === "none") return;
-	oldLine = cleanLastNewline(oldLine);
-	newLine = cleanLastNewline(newLine);
-	const lineDiff = lineDiffType === "char" ? diffChars(oldLine, newLine) : diffWordsWithSpace(oldLine, newLine);
+function computeLineDiffDecorations({ deletionLine, additionLine, deletionLineIndex, additionLineIndex, deletionDecorations, additionDecorations, lineDiffType }) {
+	if (deletionLine == null || additionLine == null || lineDiffType === "none") return;
+	deletionLine = cleanLastNewline(deletionLine);
+	additionLine = cleanLastNewline(additionLine);
+	const lineDiff = lineDiffType === "char" ? diffChars(deletionLine, additionLine) : diffWordsWithSpace(deletionLine, additionLine);
 	const deletionSpans = [];
 	const additionSpans = [];
 	const enableJoin = lineDiffType === "word-alt";
+	const lastItem = lineDiff.at(-1);
 	for (const item of lineDiff) {
-		const isLastItem = item === lineDiff[lineDiff.length - 1];
+		const isLastItem = item === lastItem;
 		if (!item.added && !item.removed) {
 			pushOrJoinSpan({
 				item,
@@ -723,8 +1119,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,
+		if (span[0] === 1) deletionDecorations.push(createDiffSpanDecoration({
+			line: deletionLineIndex,
 			spanStart: spanIndex,
 			spanLength: span[1].length
 		}));
@@ -732,159 +1128,43 @@ function computeLineDiffDecorations({ oldLine, newLine, oldLineIndex, newLineInd
 	}
 	spanIndex = 0;
 	for (const span of additionSpans) {
-		if (span[0] === 1) newDecorations.push(createDiffSpanDecoration({
-			line: newLineIndex - 1,
+		if (span[0] === 1) additionDecorations.push(createDiffSpanDecoration({
+			line: additionLineIndex,
 			spanStart: spanIndex,
 			spanLength: span[1].length
 		}));
 		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 = 0;
-			let _unifiedLineIndex = unifiedLineIndex;
-			while (i < len) {
-				const oldLine = hunkContent.deletions[i];
-				const newLine = hunkContent.additions[i];
-				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++;
-			}
-			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" ? {
@@ -906,19 +1186,19 @@ function renderTwoFiles({ oldFile, newFile, oldInfo, newInfo, highlighter: highl
 		};
 	})();
 	return {
-		oldLines: (() => {
-			if (oldFile.contents === "") return [];
-			hastConfig.lang = oldLang;
-			state.lineInfo = oldInfo;
-			hastConfig.decorations = oldDecorations;
-			return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(oldFile.contents), hastConfig));
+		deletionLines: (() => {
+			if (deletionFile.contents === "") return [];
+			hastConfig.lang = deletionLang;
+			state.lineInfo = deletionInfo;
+			hastConfig.decorations = deletionDecorations;
+			return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(deletionFile.contents), hastConfig));
 		})(),
-		newLines: (() => {
-			if (newFile.contents === "") return [];
-			hastConfig.lang = newLang;
-			hastConfig.decorations = newDecorations;
-			state.lineInfo = newInfo;
-			return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(newFile.contents), hastConfig));
+		additionLines: (() => {
+			if (additionFile.contents === "") return [];
+			hastConfig.lang = additionLang;
+			hastConfig.decorations = additionDecorations;
+			state.lineInfo = additionInfo;
+			return getLineNodes(highlighter$1.codeToHast(cleanLastNewline(additionFile.contents), hastConfig));
 		})()
 	};
 }