@pierre/diffs 1.3.0-beta.1 → 1.3.0-beta.11

package/dist/renderers/DiffHunksRenderer.js

@@ -1,8 +1,14 @@
-import { DEFAULT_COLLAPSED_CONTEXT_THRESHOLD, DEFAULT_EXPANDED_REGION, DEFAULT_RENDER_RANGE, DEFAULT_THEMES, DEFAULT_TOKENIZE_MAX_LENGTH } from "../constants.js";
+import { DEFAULT_EXPANDED_REGION, DEFAULT_RENDER_RANGE, DEFAULT_THEMES, DEFAULT_TOKENIZE_MAX_LENGTH } from "../constants.js";
+import { cleanLastNewline } from "../utils/cleanLastNewline.js";
+import { getTrailingContextRangeSize } from "../utils/virtualDiffLayout.js";
+import { preserveTrailingEditorBlankLine, recomputeDiffHunksForEdit, recomputeEmptyDocumentDiff, recomputeTopAlignedAdditionDiff, shouldTopAlignAdditionRecompute, updateDiffHunks } from "../utils/updateDiffHunks.js";
+import { applySessionChangedLines, applySessionEditWindow, findChangedLineWindow, normalizeEditorLines, remapExpandedHunksForRegionChange } from "../utils/editSessionHunks.js";
+import { getFileAnnotations, shouldRenderFileAnnotations } from "../utils/includesFileAnnotations.js";
 import { createGutterGap, createGutterItem, createGutterWrapper, createHastElement } from "../utils/hast_utils.js";
 import { areLanguagesAttached } from "../highlighter/languages/areLanguagesAttached.js";
 import { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
 import { areThemesAttached } from "../highlighter/themes/areThemesAttached.js";
+import { applyLineTextWithNewline } from "../utils/applyLineTextWithNewline.js";
 import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
 import { createAnnotationElement } from "../utils/createAnnotationElement.js";
 import { createContentColumn } from "../utils/createContentColumn.js";
@@ -24,10 +30,12 @@ import { isDefaultRenderRange } from "../utils/isDefaultRenderRange.js";
 import { isDiffPlainText } from "../utils/isDiffPlainText.js";
 import { renderDiffWithHighlighter } from "../utils/renderDiffWithHighlighter.js";
 import { toHtml } from "hast-util-to-html";
-
 //#region src/renderers/DiffHunksRenderer.ts
 let instanceId = -1;
 var DiffHunksRenderer = class {
+	options;
+	onRenderUpdate;
+	workerManager;
 	__id = `diff-hunks-renderer:${++instanceId}`;
 	highlighter;
 	diff;
@@ -36,6 +44,8 @@ var DiffHunksRenderer = class {
 	additionAnnotations = {};
 	computedLang = "text";
 	renderCache;
+	editSessionActive = false;
+	editSessionLines;
 	constructor(options = { theme: DEFAULT_THEMES }, onRenderUpdate, workerManager) {
 		this.options = options;
 		this.onRenderUpdate = onRenderUpdate;
@@ -55,9 +65,31 @@ var DiffHunksRenderer = class {
 		this.additionAnnotations = {};
 		this.deletionAnnotations = {};
 		this.workerManager?.cleanUpTasks(this);
+		this.endEditSession();
+	}
+	/**
+	* Enter edit-session mode: hunk updates preserve the current region
+	* skeleton instead of recomputing hunks. Called on every editor attach,
+	* including a re-attach after recycle, which losslessly re-seeds the pass
+	* snapshot because both hunk-update paths keep `diff.additionLines`
+	* current.
+	*/
+	beginEditSession(diff) {
+		this.editSessionActive = true;
+		this.editSessionLines = diff != null ? normalizeEditorLines(diff.additionLines).slice() : void 0;
+	}
+	/** Leave edit-session mode. The exit recompute is the host's concern. */
+	endEditSession() {
+		this.editSessionActive = false;
+		this.editSessionLines = void 0;
+	}
+	get diffCache() {
+		return this.renderCache?.diff ?? this.diff;
 	}
 	clearRenderCache() {
+		const renderCache = this.renderCache;
 		this.renderCache = void 0;
+		if (renderCache != null && renderCache.isDirty === true && renderCache.diff.cacheKey != null) this.workerManager?.evictDiffFromCache(renderCache.diff.cacheKey);
 	}
 	setOptions(options) {
 		this.options = options;
@@ -84,6 +116,10 @@ var DiffHunksRenderer = class {
 	getExpandedHunksMap() {
 		return this.expandedHunks;
 	}
+	/** Replace the whole expansion map (session-exit expansion remapping). */
+	setExpandedHunksMap(expandedHunks) {
+		this.expandedHunks = expandedHunks;
+	}
 	setLineAnnotations(lineAnnotations) {
 		this.additionAnnotations = {};
 		this.deletionAnnotations = {};
@@ -99,18 +135,146 @@ var DiffHunksRenderer = class {
 			arr.push(annotation);
 		}
 	}
+	/**
+	* Returns true when a session-mode pass changed the region skeleton itself
+	* (a gap edit synthesized or merged regions), which changes the rendered
+	* row set without a line-count change — the host must escalate to a full
+	* re-render instead of its cheap refresh path.
+	*/
+	updateRenderCache(dirtyLines, themeType, lineCountChangeInFlight = false) {
+		if (this.renderCache == null) return false;
+		const { result, diff } = this.renderCache;
+		if (result == null) return false;
+		if (diff.isPartial) throw new Error("Could not update render cache for partial diff");
+		const hastLines = result.code.additionLines;
+		const changedAdditionLines = [];
+		for (const [line, tokens] of dirtyLines) {
+			const prevProps = hastLines[line]?.properties ?? {};
+			const lineText = tokens.map((a) => a[2]).join("");
+			const canSyncDiffLine = line < diff.additionLines.length;
+			const prevLine = canSyncDiffLine ? diff.additionLines[line] ?? "" : "";
+			const prevText = cleanLastNewline(prevLine);
+			if (canSyncDiffLine) {
+				diff.additionLines[line] = applyLineTextWithNewline(prevLine, lineText);
+				if (prevText !== lineText) changedAdditionLines.push(line);
+			}
+			hastLines[line] = {
+				type: "element",
+				tagName: "div",
+				properties: {
+					"data-line": prevProps["data-line"] ?? line + 1,
+					"data-line-index": prevProps["data-line-index"] ?? line,
+					"data-line-type": prevProps["data-line-type"] ?? "context"
+				},
+				children: tokens.map(([char, fg, text]) => {
+					if (char === 0 && fg === "") {
+						if (text === "") return {
+							type: "element",
+							tagName: "br",
+							properties: {},
+							children: []
+						};
+						return {
+							type: "text",
+							value: text
+						};
+					}
+					return {
+						type: "element",
+						tagName: "span",
+						properties: {
+							"data-char": char,
+							style: `color:${fg};`
+						},
+						children: [{
+							type: "text",
+							value: text
+						}]
+					};
+				})
+			};
+		}
+		let regionsChanged = false;
+		if (changedAdditionLines.length > 0) if (this.editSessionActive && !diff.isPartial) {
+			if (!lineCountChangeInFlight) {
+				const changes = applySessionChangedLines(diff, changedAdditionLines, this.options.parseDiffOptions);
+				this.applyExpansionRemaps(changes);
+				regionsChanged = changes.length > 0;
+				this.editSessionLines = normalizeEditorLines(diff.additionLines).slice();
+			}
+		} else Object.assign(diff, updateDiffHunks(diff, changedAdditionLines, this.options.parseDiffOptions));
+		result.baseThemeType = themeType;
+		this.renderCache.isDirty = true;
+		return regionsChanged;
+	}
+	applyExpansionRemaps(changes) {
+		for (const change of changes) this.expandedHunks = remapExpandedHunksForRegionChange(this.expandedHunks, change);
+	}
+	applyDocumentChange(textDocument) {
+		if (this.renderCache == null) return;
+		const { diff, result } = this.renderCache;
+		if (result == null) return;
+		diff.additionLines = getEditorDocumentLines(textDocument, diff.additionLines);
+		const newLength = diff.additionLines.length;
+		const additionHastLines = result.code.additionLines;
+		const prevLen = additionHastLines.length;
+		if (newLength < prevLen) additionHastLines.length = newLength;
+		for (let i = prevLen; i < newLength; i++) additionHastLines[i] ??= createPlainAdditionLineElement(i, textDocument);
+		if (!diff.isPartial) if (diff.additionLines.length <= 1 && diff.additionLines.join("") === "") {
+			Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
+			additionHastLines[0] = createPlainAdditionLineElement(0, textDocument);
+			this.markEditSessionPass(diff);
+		} else if (this.editSessionActive) this.applySessionDocumentChange(diff);
+		else Object.assign(diff, recomputeDiffHunksForEdit(diff, this.options.parseDiffOptions));
+		this.renderCache.isDirty = true;
+	}
+	applySessionDocumentChange(diff) {
+		const { parseDiffOptions } = this.options;
+		const rawLines = diff.additionLines;
+		if (shouldTopAlignAdditionRecompute(diff, rawLines)) {
+			Object.assign(diff, recomputeTopAlignedAdditionDiff(diff, rawLines, parseDiffOptions));
+			this.markEditSessionPass(diff);
+			return;
+		}
+		const previousLines = this.editSessionLines;
+		const nextLines = normalizeEditorLines(rawLines);
+		if (previousLines == null) {
+			Object.assign(diff, recomputeDiffHunksForEdit(diff, parseDiffOptions));
+			this.markEditSessionPass(diff);
+			return;
+		}
+		diff.additionLines = nextLines;
+		const window = findChangedLineWindow(previousLines, nextLines);
+		if (window != null) {
+			const change = applySessionEditWindow(diff, window, parseDiffOptions);
+			if (change != null) this.applyExpansionRemaps([change]);
+		}
+		preserveTrailingEditorBlankLine(diff, rawLines);
+		this.editSessionLines = nextLines.slice();
+	}
+	markEditSessionPass(diff) {
+		if (!this.editSessionActive) return;
+		diff.editSessionDirty = true;
+		this.editSessionLines = normalizeEditorLines(diff.additionLines).slice();
+	}
 	getUnifiedLineDecoration({ lineType }) {
-		return { gutterLineType: lineType };
+		return {
+			gutterLineType: lineType,
+			contentProperties: { "data-line-type": lineType }
+		};
 	}
 	getSplitLineDecoration({ side, type }) {
-		if (type !== "change") return { gutterLineType: type };
-		return { gutterLineType: side === "deletions" ? "change-deletion" : "change-addition" };
+		const lineType = type === "change" ? side === "deletions" ? "change-deletion" : "change-addition" : type;
+		return {
+			gutterLineType: lineType,
+			contentProperties: { "data-line-type": lineType }
+		};
 	}
-	createAnnotationElement(span) {
+	createAnnotationElement = (span) => {
 		return createAnnotationElement(span);
-	}
+	};
 	getOptionsWithDefaults() {
-		const { diffIndicators = "bars", diffStyle = "split", disableBackground = false, disableFileHeader = false, disableLineNumbers = false, disableVirtualizationBuffers = false, collapsed = false, expandUnchanged = false, collapsedContextThreshold = DEFAULT_COLLAPSED_CONTEXT_THRESHOLD, expansionLineCount = 100, hunkSeparators = "line-info", lineDiffType = "word-alt", maxLineDiffLength = 1e3, overflow = "scroll", stickyHeader = false, theme = DEFAULT_THEMES, headerRenderMode = "default", tokenizeMaxLineLength = 1e3, tokenizeMaxLength = DEFAULT_TOKENIZE_MAX_LENGTH, useTokenTransformer = false, useCSSClasses = false } = this.options;
+		const { diffIndicators = "bars", diffStyle = "split", disableBackground = false, disableFileHeader = false, disableLineNumbers = false, disableVirtualizationBuffers = false, collapsed = false, expandUnchanged = false, collapsedContextThreshold = 1, expansionLineCount = 100, hunkSeparators = "line-info", lineDiffType = "word-alt", maxLineDiffLength = 1e3, overflow = "scroll", stickyHeader = false, theme = DEFAULT_THEMES, headerRenderMode = "default", tokenizeMaxLineLength = 1e3, tokenizeMaxLength = DEFAULT_TOKENIZE_MAX_LENGTH, useTokenTransformer = false, useCSSClasses = false } = this.options;
 		return {
 			diffIndicators,
 			diffStyle,
@@ -189,7 +353,7 @@ var DiffHunksRenderer = class {
 	}
 	renderDiff(diff = this.renderCache?.diff, renderRange = DEFAULT_RENDER_RANGE) {
 		if (diff == null) return;
-		const { expandUnchanged = false, collapsedContextThreshold } = this.getOptionsWithDefaults();
+		const { expandUnchanged, collapsedContextThreshold } = this.getOptionsWithDefaults();
 		let { options, forceHighlight } = this.getRenderOptions(diff);
 		const cache = this.getMatchingWorkerResultCache(diff, options);
 		if (cache != null && !this.hasHighlightedRenderCache(diff, options)) {
@@ -227,18 +391,18 @@ var DiffHunksRenderer = class {
 			const hasLangs = this.highlighter != null && areLanguagesAttached(this.computedLang);
 			const canHighlight = !forcePlainText && hasLangs;
 			if (this.highlighter != null && hasThemes && (forceHighlight || forcePlainText || !this.renderCache.highlighted && canHighlight || this.renderCache.result == null)) {
-				const { result, options: options$1 } = this.renderDiffWithHighlighter(diff, this.highlighter, forcePlainText || !hasLangs);
+				const { result, options } = this.renderDiffWithHighlighter(diff, this.highlighter, forcePlainText || !hasLangs);
 				this.renderCache = {
 					diff,
-					options: options$1,
+					options,
 					highlighted: canHighlight,
 					result,
 					renderRange: void 0
 				};
 			}
-			if (!hasThemes || !forcePlainText && !hasLangs) this.asyncHighlight(diff).then(({ result, options: options$1 }) => {
+			if (!hasThemes || !forcePlainText && !hasLangs) this.asyncHighlight(diff).then(({ result, options }) => {
 				if (this.renderCache != null) this.renderCache.highlighted = false;
-				this.onHighlightSuccess(diff, result, options$1, !forcePlainText);
+				this.onHighlightSuccess(diff, result, options, !forcePlainText);
 			});
 		}
 		return this.renderCache.result != null ? this.processDiffResult(this.renderCache.diff, renderRange, this.renderCache.result) : void 0;
@@ -305,12 +469,15 @@ var DiffHunksRenderer = class {
 		console.error(error);
 	}
 	getTokenizeMaxLength() {
-		return this.options.tokenizeMaxLength ?? DEFAULT_TOKENIZE_MAX_LENGTH;
+		return this.options.tokenizeMaxLength ?? 1e5;
 	}
 	processDiffResult(fileDiff, renderRange, { code, themeStyles, baseThemeType }) {
 		const { diffStyle, disableFileHeader, expandUnchanged, expansionLineCount, collapsedContextThreshold, hunkSeparators } = this.getOptionsWithDefaults();
+		const isRenderCacheDirty = this.renderCache?.isDirty ?? false;
 		this.diff = fileDiff;
 		const unified = diffStyle === "unified";
+		const canHydrateContext = canHydrateCollapsedContext(fileDiff, this.options.loadDiffFiles != null);
+		const isExpandableDiff = !fileDiff.isPartial || canHydrateContext;
 		let additionsContentAST = [];
 		let deletionsContentAST = [];
 		let unifiedContentAST = [];
@@ -344,7 +511,10 @@ var DiffHunksRenderer = class {
 				}
 			}
 		};
-		const trailingRangeSize = calculateTrailingRangeSize(fileDiff);
+		const trailingRangeSize = getTrailingContextRangeSize({
+			fileDiff,
+			errorPrefix: "DiffHunksRenderer.processDiffResult"
+		});
 		const pendingSplitContext = {
 			size: 0,
 			side: void 0,
@@ -380,6 +550,7 @@ var DiffHunksRenderer = class {
 				pushSeparator("additions", props, context);
 			}
 		}
+		this.pushFileLevelAnnotations(fileDiff, diffStyle, renderRange, context);
 		iterateOverDiff({
 			diff: fileDiff,
 			diffStyle,
@@ -398,7 +569,7 @@ var DiffHunksRenderer = class {
 					hunkSpecs: hunk?.hunkSpecs,
 					isFirstHunk: hunkIndex === 0,
 					isLastHunk: false,
-					isExpandable: !fileDiff.isPartial
+					isExpandable: isExpandableDiff
 				});
 				const lineIndex = diffStyle === "unified" ? unifiedLineIndex : splitLineIndex;
 				const renderedLineContext = {
@@ -428,8 +599,14 @@ var DiffHunksRenderer = class {
 						deletionLineIndex: deletionLine?.lineIndex
 					});
 					pushGutterLineNumber("unified", lineDecoration.gutterLineType, additionLine != null ? additionLine.lineNumber : deletionLine.lineNumber, `${unifiedLineIndex},${splitLineIndex}`, lineDecoration.gutterProperties);
-					if (additionLineContent != null) additionLineContent = withContentProperties(additionLineContent, lineDecoration.contentProperties);
-					else if (deletionLineContent != null) deletionLineContent = withContentProperties(deletionLineContent, lineDecoration.contentProperties);
+					if (additionLineContent != null) additionLineContent = withContentProperties(additionLineContent, lineDecoration.contentProperties, isRenderCacheDirty && additionLine != null ? {
+						"data-line": additionLine.lineNumber,
+						"data-line-index": `${unifiedLineIndex},${splitLineIndex}`
+					} : void 0);
+					else if (deletionLineContent != null) deletionLineContent = withContentProperties(deletionLineContent, lineDecoration.contentProperties, isRenderCacheDirty && deletionLine != null ? {
+						"data-line": deletionLine.lineNumber,
+						"data-line-index": `${unifiedLineIndex},${splitLineIndex}`
+					} : void 0);
 					pushLineWithAnnotation({
 						diffStyle: "unified",
 						type,
@@ -467,19 +644,25 @@ var DiffHunksRenderer = class {
 						}
 					})();
 					if (missingSide != null) {
-						if (pendingSplitContext.side != null && pendingSplitContext.side !== missingSide) throw new Error("DiffHunksRenderer.processDiffResult: iterateOverDiff, invalid pending splits");
+						if (pendingSplitContext.side != null && pendingSplitContext.side !== missingSide) pendingSplitContext.flush();
 						pendingSplitContext.side = missingSide;
 						pendingSplitContext.increment();
-					}
+					} else if (type === "change") pendingSplitContext.flush();
 					const annotationSpans = this.getAnnotations("split", deletionLine?.lineNumber, additionLine?.lineNumber, hunkIndex, lineIndex);
 					if (annotationSpans != null && pendingSplitContext.size > 0) pendingSplitContext.flush();
 					if (deletionLine != null) {
-						const deletionLineDecorated = withContentProperties(deletionLineContent, deletionLineDecoration.contentProperties);
+						const deletionLineDecorated = withContentProperties(deletionLineContent, deletionLineDecoration.contentProperties, isRenderCacheDirty ? {
+							"data-line": deletionLine.lineNumber,
+							"data-line-index": `${deletionLine.unifiedLineIndex},${splitLineIndex}`
+						} : void 0);
 						pushGutterLineNumber("deletions", deletionLineDecoration.gutterLineType, deletionLine.lineNumber, `${deletionLine.unifiedLineIndex},${splitLineIndex}`, deletionLineDecoration.gutterProperties);
 						if (deletionLineDecorated != null) deletionLineContent = deletionLineDecorated;
 					}
 					if (additionLine != null) {
-						const additionLineDecorated = withContentProperties(additionLineContent, additionLineDecoration.contentProperties);
+						const additionLineDecorated = withContentProperties(additionLineContent, additionLineDecoration.contentProperties, isRenderCacheDirty ? {
+							"data-line": additionLine.lineNumber,
+							"data-line-index": `${additionLine.unifiedLineIndex},${splitLineIndex}`
+						} : void 0);
 						pushGutterLineNumber("additions", additionLineDecoration.gutterLineType, additionLine.lineNumber, `${additionLine.unifiedLineIndex},${splitLineIndex}`, additionLineDecoration.gutterProperties);
 						if (additionLineDecorated != null) additionLineContent = additionLineDecorated;
 					}
@@ -495,6 +678,7 @@ var DiffHunksRenderer = class {
 					if (injectedRows?.after != null) pushSplitInjectedRows(injectedRows.after, context, pendingSplitContext);
 				}
 				const isFinalSplitHunkRow = diffStyle === "split" && hunk != null && splitLineIndex === hunk.splitLineStart + hunk.splitLineCount - 1;
+				const isFinalHunkRow = hunkIndex === fileDiff.hunks.length - 1 && hunk != null && (diffStyle === "split" ? splitLineIndex === hunk.splitLineStart + hunk.splitLineCount - 1 : unifiedLineIndex === hunk.unifiedLineStart + hunk.unifiedLineCount - 1);
 				const splitNoEOFCRDeletion = isFinalSplitHunkRow ? hunk.noEOFCRDeletions : false;
 				const splitNoEOFCRAddition = isFinalSplitHunkRow ? hunk.noEOFCRAdditions : false;
 				const noEOFCRDeletion = (deletionLine?.noEOFCR ?? false) || splitNoEOFCRDeletion;
@@ -531,14 +715,14 @@ var DiffHunksRenderer = class {
 					}
 					context.incrementRowCount(1);
 				}
-				if (collapsedAfter > 0 && hunkSeparators !== "simple") pushSeparators({
+				if (hunkSeparators !== "simple" && hunkSeparators !== "metadata" && (collapsedAfter > 0 || isFinalHunkRow && canHydrateContext)) pushSeparators({
 					hunkIndex: type === "context-expanded" ? hunkIndex : hunkIndex + 1,
-					collapsedLines: collapsedAfter,
+					collapsedLines: isFinalHunkRow && canHydrateContext ? "unknown" : collapsedAfter,
 					rangeSize: trailingRangeSize,
 					hunkSpecs: void 0,
 					isFirstHunk: false,
 					isLastHunk: true,
-					isExpandable: !fileDiff.isPartial
+					isExpandable: isExpandableDiff
 				});
 				context.incrementRowCount(1);
 			}
@@ -638,6 +822,48 @@ var DiffHunksRenderer = class {
 			}
 		}));
 	}
+	pushFileLevelAnnotations(fileDiff, diffStyle, renderRange, context) {
+		if (!shouldRenderFileAnnotations(renderRange)) return;
+		const deletionAnnotationNames = fileDiff.type !== "new" ? getAnnotationNames(getFileAnnotations(this.deletionAnnotations)) : [];
+		const additionAnnotationNames = fileDiff.type !== "deleted" ? getAnnotationNames(getFileAnnotations(this.additionAnnotations)) : [];
+		if (deletionAnnotationNames.length === 0 && additionAnnotationNames.length === 0) return;
+		const hunkIndex = -1;
+		const lineIndex = -1;
+		const { createAnnotationElement } = this;
+		if (diffStyle === "unified") {
+			pushLineWithAnnotation({
+				diffStyle,
+				type: "context",
+				unifiedSpan: {
+					type: "annotation",
+					hunkIndex,
+					lineIndex,
+					annotations: deletionAnnotationNames.concat(additionAnnotationNames)
+				},
+				createAnnotationElement,
+				context
+			});
+			return;
+		}
+		pushLineWithAnnotation({
+			diffStyle,
+			type: "context",
+			deletionSpan: {
+				type: "annotation",
+				hunkIndex,
+				lineIndex,
+				annotations: deletionAnnotationNames
+			},
+			additionSpan: {
+				type: "annotation",
+				hunkIndex,
+				lineIndex,
+				annotations: additionAnnotationNames
+			},
+			createAnnotationElement,
+			context
+		});
+	}
 	getAnnotations(type, deletionLineNumber, additionLineNumber, hunkIndex, lineIndex) {
 		const deletionSpan = {
 			type: "annotation",
@@ -672,8 +898,12 @@ var DiffHunksRenderer = class {
 		});
 	}
 };
+function getAnnotationNames(annotations) {
+	return annotations?.map((annotation) => getLineAnnotationName(annotation)) ?? [];
+}
+const EN_PLURAL_RULES = new Intl.PluralRules("en-US");
 function getModifiedLinesString(lines) {
-	return `${lines} unmodified line${lines > 1 ? "s" : ""}`;
+	return `${lines} unmodified line${EN_PLURAL_RULES.select(lines) === "one" ? "" : "s"}`;
 }
 function pushUnifiedInjectedRows(rows, context) {
 	for (const row of rows) {
@@ -702,14 +932,14 @@ function pushSplitInjectedRows(rows, context, pendingSplitContext) {
 		context.incrementRowCount(1);
 	}
 }
-function pushLineWithAnnotation({ diffStyle, type, deletionLine, additionLine, unifiedSpan, deletionSpan, additionSpan, createAnnotationElement: createAnnotationElement$1, context }) {
+function pushLineWithAnnotation({ diffStyle, type, deletionLine, additionLine, unifiedSpan, deletionSpan, additionSpan, createAnnotationElement, context }) {
 	let hasAnnotationRow = false;
 	if (diffStyle === "unified") {
 		if (additionLine != null) context.unifiedContentAST.push(additionLine);
 		else if (deletionLine != null) context.unifiedContentAST.push(deletionLine);
 		if (unifiedSpan != null) {
 			const lineType = type === "change" ? deletionLine != null ? "change-deletion" : "change-addition" : type;
-			context.unifiedContentAST.push(createAnnotationElement$1(unifiedSpan));
+			context.unifiedContentAST.push(createAnnotationElement(unifiedSpan));
 			context.pushToGutter("unified", createGutterGap(lineType, "annotation", 1));
 			hasAnnotationRow = true;
 		}
@@ -718,13 +948,13 @@ function pushLineWithAnnotation({ diffStyle, type, deletionLine, additionLine, u
 		if (additionLine != null) context.additionsContentAST.push(additionLine);
 		if (deletionSpan != null) {
 			const lineType = type === "change" ? deletionLine != null ? "change-deletion" : "context" : type;
-			context.deletionsContentAST.push(createAnnotationElement$1(deletionSpan));
+			context.deletionsContentAST.push(createAnnotationElement(deletionSpan));
 			context.pushToGutter("deletions", createGutterGap(lineType, "annotation", 1));
 			hasAnnotationRow = true;
 		}
 		if (additionSpan != null) {
 			const lineType = type === "change" ? additionLine != null ? "change-addition" : "context" : type;
-			context.additionsContentAST.push(createAnnotationElement$1(additionSpan));
+			context.additionsContentAST.push(createAnnotationElement(additionSpan));
 			context.pushToGutter("additions", createGutterGap(lineType, "annotation", 1));
 			hasAnnotationRow = true;
 		}
@@ -732,7 +962,7 @@ function pushLineWithAnnotation({ diffStyle, type, deletionLine, additionLine, u
 	if (hasAnnotationRow) context.incrementRowCount(1);
 }
 function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs, isFirstHunk, isLastHunk, isExpandable }, context) {
-	if (collapsedLines <= 0) return;
+	if (typeof collapsedLines === "number" && collapsedLines <= 0) return;
 	const linesAST = type === "unified" ? context.unifiedContentAST : type === "deletions" ? context.deletionsContentAST : context.additionsContentAST;
 	if (context.hunkSeparators === "metadata") {
 		if (hunkSpecs != null) {
@@ -771,9 +1001,10 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	const slotName = getHunkSeparatorSlotName(type, hunkIndex);
 	const chunked = rangeSize > context.expansionLineCount;
 	const expandIndex = isExpandable ? hunkIndex : void 0;
+	const content = typeof collapsedLines === "number" ? getModifiedLinesString(collapsedLines) : "More unchanged context may be available";
 	context.pushToGutter(type, createSeparator({
 		type: context.hunkSeparators,
-		content: getModifiedLinesString(collapsedLines),
+		content,
 		expandIndex,
 		chunked,
 		slotName,
@@ -782,7 +1013,7 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	}));
 	linesAST.push(createSeparator({
 		type: context.hunkSeparators,
-		content: getModifiedLinesString(collapsedLines),
+		content,
 		expandIndex,
 		chunked,
 		slotName,
@@ -793,7 +1024,8 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	context.hunkData.push({
 		slotName,
 		hunkIndex,
-		lines: collapsedLines,
+		lines: typeof collapsedLines === "number" ? collapsedLines : 0,
+		lineCountKnown: typeof collapsedLines === "number",
 		type,
 		expandable: isExpandable ? {
 			up: !isFirstHunk,
@@ -802,28 +1034,64 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 		} : void 0
 	});
 }
-function withContentProperties(lineNode, contentProperties) {
-	if (lineNode == null || lineNode.type !== "element" || contentProperties == null) return lineNode;
+function withContentProperties(lineNode, contentProperties, extendProperties) {
+	if (lineNode == null || lineNode.type !== "element" || contentProperties == null && extendProperties == null) return lineNode;
 	return {
 		...lineNode,
 		properties: {
 			...lineNode.properties,
-			...contentProperties
+			...contentProperties,
+			...extendProperties
 		}
 	};
 }
+function createPlainAdditionLineElement(lineIndex, textDocument) {
+	return {
+		type: "element",
+		tagName: "div",
+		properties: {
+			"data-line": lineIndex + 1,
+			"data-line-index": `${lineIndex},${lineIndex}`,
+			"data-line-type": "context"
+		},
+		children: [{
+			type: "element",
+			tagName: "span",
+			properties: { "data-char": 0 },
+			children: [{
+				type: "text",
+				value: textDocument.getLineText(lineIndex)
+			}]
+		}]
+	};
+}
+function getEditorDocumentLines(textDocument, previousLines) {
+	const lines = [];
+	const fallbackLineBreak = getFallbackLineBreak(previousLines);
+	for (let line = 0; line < textDocument.lineCount; line++) {
+		const lineText = textDocument.getLineText(line, true);
+		lines.push(line < textDocument.lineCount - 1 && !hasLineBreakSuffix(lineText) ? lineText + fallbackLineBreak : lineText);
+	}
+	return lines;
+}
+function hasLineBreakSuffix(line) {
+	return line.endsWith("\n") || line.endsWith("\r");
+}
+function getFallbackLineBreak(lines) {
+	for (const line of lines) {
+		if (line.endsWith("\r\n")) return "\r\n";
+		if (line.endsWith("\n")) return "\n";
+		if (line.endsWith("\r")) return "\r";
+	}
+	return "\n";
+}
 function isDiffMassive(diff, tokenizeMaxLength) {
 	return Math.max(diff.additionLines.length, diff.deletionLines.length) > tokenizeMaxLength;
 }
-function calculateTrailingRangeSize(fileDiff) {
-	const lastHunk = fileDiff.hunks.at(-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 !== deletionRemaining) throw new Error(`DiffHunksRenderer.processDiffResult: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${fileDiff.name}`);
-	return Math.min(additionRemaining, deletionRemaining);
+function canHydrateCollapsedContext(fileDiff, hasFileLoader) {
+	return fileDiff.isPartial && hasFileLoader && (fileDiff.type === "change" || fileDiff.type === "rename-changed");
 }
-
 //#endregion
 export { DiffHunksRenderer };
+
 //# sourceMappingURL=DiffHunksRenderer.js.map