@pierre/diffs 1.3.6 → 1.4.1

package/dist/renderers/DiffHunksRenderer.js

@@ -1,13 +1,9 @@
 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 { recomputeDiffHunksForEdit, recomputeEmptyDocumentDiff, recomputeTopAlignedAdditionDiff, shouldTopAlignAdditionRecompute, updateDiffHunks } from "../utils/updateDiffHunks.js";
-import { applySessionChangedLines, rebuildSessionHunks, 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 { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
+import { getFileAnnotations, shouldRenderFileAnnotations } from "../utils/includesFileAnnotations.js";
+import { createGutterGap, createGutterItem, createGutterWrapper, createHastElement } from "../utils/hast_utils.js";
 import { applyLineTextWithNewline } from "../utils/applyLineTextWithNewline.js";
 import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
 import { createAnnotationElement } from "../utils/createAnnotationElement.js";
@@ -17,15 +13,19 @@ import { createPreElement } from "../utils/createPreElement.js";
 import { getFiletypeFromFileName } from "../utils/getFiletypeFromFileName.js";
 import { getHighlighterOptions } from "../utils/getHighlighterOptions.js";
 import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
+import { isDefaultRenderRange } from "../utils/isDefaultRenderRange.js";
 import { areDiffTargetsEqual } from "../utils/areDiffTargetsEqual.js";
+import { getTrailingContextRangeSize } from "../utils/virtualDiffLayout.js";
 import { iterateOverDiff } from "../utils/iterateOverDiff.js";
+import { cleanLastNewline } from "../utils/cleanLastNewline.js";
 import { areDiffRenderOptionsEqual } from "../utils/areDiffRenderOptionsEqual.js";
 import { createEmptyRowBuffer } from "../utils/createEmptyRowBuffer.js";
 import { createNoNewlineElement } from "../utils/createNoNewlineElement.js";
 import { createSeparator } from "../utils/createSeparator.js";
+import { recomputeDiffHunksForEdit, recomputeEmptyDocumentDiff, recomputeTopAlignedAdditionDiff, shouldTopAlignAdditionRecompute, updateDiffHunks } from "../utils/updateDiffHunks.js";
+import { applySessionChangedLines, rebuildSessionHunks, remapExpandedHunksForRegionChange } from "../utils/editSessionHunks.js";
 import { getHunkSeparatorSlotName } from "../utils/getHunkSeparatorSlotName.js";
 import { getTotalLineCountFromHunks } from "../utils/getTotalLineCountFromHunks.js";
-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";
@@ -33,6 +33,7 @@ import { toHtml } from "hast-util-to-html";
 let instanceId = -1;
 var DiffHunksRenderer = class {
 	options;
+	annotationSlotName;
 	onRenderUpdate;
 	workerManager;
 	__id = `diff-hunks-renderer:${++instanceId}`;
@@ -43,9 +44,12 @@ var DiffHunksRenderer = class {
 	additionAnnotations = {};
 	computedLang = "text";
 	renderCache;
+	pendingHighlightResult;
+	pendingStructuralRows;
 	editSessionActive = false;
-	constructor(options = { theme: DEFAULT_THEMES }, onRenderUpdate, workerManager) {
+	constructor(options = { theme: DEFAULT_THEMES }, annotationSlotName = getLineAnnotationName, onRenderUpdate, workerManager) {
 		this.options = options;
+		this.annotationSlotName = annotationSlotName;
 		this.onRenderUpdate = onRenderUpdate;
 		this.workerManager = workerManager;
 		if (workerManager?.isWorkingPool() !== true) this.highlighter = areThemesAttached(options.theme ?? DEFAULT_THEMES) ? getHighlighterIfLoaded() : void 0;
@@ -69,22 +73,51 @@ var DiffHunksRenderer = class {
 	* Enter edit-session mode: hunk updates preserve the current region
 	* skeleton instead of recomputing hunks, and rendering happens locally
 	* with the token transformer forced on (worker-pool requests/results are
-	* suspended for this renderer). An empty additions document gets one row so
-	* the editor has a line for its caret. Called on every editor attach,
-	* including a re-attach after recycle.
+	* suspended for this renderer). When the session was freshly cloned from
+	* `externalDiff`, compatible highlighted markup is detached from its external
+	* cache owner so the editor can reuse it without mutating shared data. An
+	* empty additions document gets one row for the editor's caret.
 	*/
-	beginEditSession() {
+	beginEditSession(diff, externalDiff) {
+		const { editSessionActive: wasAlreadyActive, renderCache } = this;
 		this.editSessionActive = true;
-		const diff = this.diffCache;
-		if (diff != null && !diff.isPartial && diff.additionLines.length === 0) {
+		if (!wasAlreadyActive) this.pendingHighlightResult = void 0;
+		this.diff = diff;
+		if (!diff.isPartial && diff.additionLines.length === 0) {
 			Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
 			this.markEditSessionPass(diff);
 			this.clearRenderCache();
+			return;
+		}
+		if (renderCache == null) return;
+		if (wasAlreadyActive && renderCache.diff === diff) return;
+		const { options } = this.getRenderOptions(diff);
+		const cacheBelongsToSession = renderCache.diff === diff;
+		const cacheBelongsToExternal = externalDiff != null && areDiffTargetsEqual(renderCache.diff, externalDiff);
+		const { result } = renderCache;
+		if (!renderCache.highlighted || result == null || !areDiffRenderOptionsEqual(renderCache.options, options) || !cacheBelongsToSession && !cacheBelongsToExternal) {
+			this.clearRenderCache();
+			return;
 		}
+		if (cacheBelongsToSession) return;
+		this.renderCache = {
+			diff,
+			options,
+			highlighted: true,
+			result: {
+				...result,
+				code: {
+					...result.code,
+					additionLines: [...result.code.additionLines]
+				}
+			},
+			renderRange: renderCache.renderRange
+		};
 	}
 	/** Leave edit-session mode. The exit recompute is the host's concern. */
 	endEditSession() {
 		this.editSessionActive = false;
+		this.pendingHighlightResult = void 0;
 	}
 	/**
 	* Ensures that the DOM is compatible with editor render updates
@@ -93,20 +126,17 @@ var DiffHunksRenderer = class {
 		return this.renderCache?.options.useTokenTransformer === true && this.renderCache.highlighted && this.renderCache.result != null;
 	}
 	/**
-	* Re-highlights the current diff in the background and swaps the fresh
-	* result in (with a re-render) once it completes. Needed after an edit
-	* session's exit recompute: session passes plain-fill shifted lines in the
-	* cached result, and the recompute mutates the diff in place (same object,
-	* same cacheKey), so identity/cacheKey checks would otherwise treat the
-	* stale highlight as current forever. The current result — content-correct,
-	* mostly highlighted — keeps rendering until the fresh one lands, so no
-	* interim paint drops highlighting.
+	* Re-highlights the current diff in the background and stages the fresh
+	* result for the next render. Needed after an edit session's exit recompute:
+	* session passes plain-fill shifted lines in the cached result, and the
+	* recompute mutates the keyless session diff in place, so object identity
+	* alone would otherwise treat the stale highlight as current forever. The
+	* current result — content-correct, mostly highlighted — keeps rendering
+	* until the fresh one is promoted, so no interim paint drops highlighting.
 	*/
 	refreshHighlightedResult() {
-		const { renderCache } = this;
-		if (renderCache == null || isDiffPlainText(renderCache.diff) || isDiffMassive(renderCache.diff, this.getTokenizeMaxLength())) return Promise.resolve();
-		const { diff } = renderCache;
-		const { workerManager } = this;
+		const { diff, renderCache, workerManager } = this;
+		if (diff == null || renderCache == null || !areDiffTargetsEqual(renderCache.diff, diff) || isDiffPlainText(diff) || isDiffMassive(diff, this.getTokenizeMaxLength())) return Promise.resolve();
 		if (!this.editSessionActive && workerManager?.isWorkingPool() === true && diff.cacheKey != null) {
 			workerManager.evictDiffFromCache(diff.cacheKey);
 			return workerManager.primeDiffHighlightCache(diff).then(() => {
@@ -116,15 +146,15 @@ var DiffHunksRenderer = class {
 		return this.asyncHighlight(diff).then((fresh) => this.applyRefreshedResult(diff, fresh)).catch((error) => this.onHighlightError(error));
 	}
 	applyRefreshedResult(diff, fresh) {
-		if (fresh == null || this.renderCache == null || this.renderCache.diff !== diff || this.editSessionActive) return;
-		const { options } = this.getRenderOptions(diff);
+		const { diff: currentDiff, renderCache } = this;
+		if (fresh == null || currentDiff == null || renderCache == null || !areDiffTargetsEqual(currentDiff, diff) || !areDiffTargetsEqual(renderCache.diff, diff) || this.editSessionActive) return;
+		const { options } = this.getRenderOptions(currentDiff);
 		if (!areDiffRenderOptionsEqual(options, fresh.options)) return;
-		this.renderCache = {
-			diff,
+		this.pendingHighlightResult = {
+			diff: currentDiff,
 			options: fresh.options,
 			highlighted: true,
-			result: fresh.result,
-			renderRange: void 0
+			result: fresh.result
 		};
 		this.onRenderUpdate?.();
 	}
@@ -132,9 +162,9 @@ var DiffHunksRenderer = class {
 		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);
+		this.pendingHighlightResult = void 0;
+		this.pendingStructuralRows = void 0;
 	}
 	setOptions(options) {
 		this.options = options;
@@ -187,11 +217,14 @@ var DiffHunksRenderer = class {
 	* re-render instead of its cheap refresh path.
 	*/
 	updateRenderCache(dirtyLines, themeType, lineCountChangeInFlight = false) {
-		if (this.renderCache == null) return false;
-		const { result, diff } = this.renderCache;
+		this.pendingStructuralRows = void 0;
+		const { renderCache } = this;
+		if (renderCache == null) return false;
+		const { result, diff } = 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 pendingStructuralRows = this.pendingStructuralRows = lineCountChangeInFlight ? /* @__PURE__ */ new Map() : void 0;
 		const changedAdditionLines = [];
 		const previousAdditionLines = /* @__PURE__ */ new Map();
 		for (const [line, tokens] of dirtyLines) {
@@ -200,14 +233,14 @@ var DiffHunksRenderer = class {
 			const canSyncDiffLine = line < diff.additionLines.length;
 			const prevLine = canSyncDiffLine ? diff.additionLines[line] ?? "" : "";
 			const prevText = cleanLastNewline(prevLine);
-			if (canSyncDiffLine) {
+			if (pendingStructuralRows == null && canSyncDiffLine) {
 				diff.additionLines[line] = applyLineTextWithNewline(prevLine, lineText);
 				if (prevText !== lineText) {
 					changedAdditionLines.push(line);
 					previousAdditionLines.set(line, prevLine);
 				}
 			}
-			hastLines[line] = {
+			const row = {
 				type: "element",
 				tagName: "div",
 				properties: {
@@ -242,56 +275,64 @@ var DiffHunksRenderer = class {
 					};
 				})
 			};
+			if (pendingStructuralRows != null) pendingStructuralRows.set(line, row);
+			else hastLines[line] = row;
 		}
 		let regionsChanged = false;
-		if (changedAdditionLines.length > 0) if (this.editSessionActive && !diff.isPartial) {
-			if (!lineCountChangeInFlight) if (diff.additionLines.length <= 1 && diff.additionLines.join("") === "") {
-				Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
-				this.markEditSessionPass(diff);
-				regionsChanged = true;
-			} else if (shouldTopAlignAdditionRecompute(diff, diff.additionLines)) {
-				Object.assign(diff, recomputeTopAlignedAdditionDiff(diff, diff.additionLines, this.options.parseDiffOptions));
-				this.markEditSessionPass(diff);
-				regionsChanged = true;
-			} else {
-				const change = applySessionChangedLines(diff, changedAdditionLines, this.options.parseDiffOptions, previousAdditionLines);
-				this.applyExpansionRemap(change);
-				regionsChanged = change != null;
-			}
-		} else Object.assign(diff, updateDiffHunks(diff, changedAdditionLines, this.options.parseDiffOptions));
+		if (changedAdditionLines.length > 0) if (this.editSessionActive) if (diff.additionLines.length <= 1 && diff.additionLines.join("") === "") {
+			this.applyRecomputePreservingSessionType(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
+			regionsChanged = true;
+		} else if (shouldTopAlignAdditionRecompute(diff, diff.additionLines)) {
+			this.applyRecomputePreservingSessionType(diff, recomputeTopAlignedAdditionDiff(diff, diff.additionLines, this.options.parseDiffOptions));
+			regionsChanged = true;
+		} else {
+			const change = applySessionChangedLines(diff, changedAdditionLines, this.options.parseDiffOptions, previousAdditionLines);
+			this.applyExpansionRemap(change);
+			regionsChanged = change != null;
+		}
+		else Object.assign(diff, updateDiffHunks(diff, changedAdditionLines, this.options.parseDiffOptions));
 		result.baseThemeType = themeType;
-		this.renderCache.isDirty = true;
+		renderCache.isDirty = true;
 		return regionsChanged;
 	}
 	applyExpansionRemap(change) {
 		if (change != null) this.expandedHunks = remapExpandedHunksForRegionChange(this.expandedHunks, change);
 	}
 	applyDocumentChange(textDocument) {
-		if (this.renderCache == null) return;
-		const { diff, result } = this.renderCache;
+		const { pendingStructuralRows, renderCache } = this;
+		this.pendingStructuralRows = void 0;
+		if (renderCache == null) return;
+		const { diff, result } = renderCache;
 		if (result == null) return;
 		if (diff.isPartial) throw new Error("Could not apply document change for partial diff");
 		const { additionLines: previousAdditionLines } = diff;
-		diff.additionLines = getEditorDocumentLines(textDocument, previousAdditionLines);
+		diff.additionLines = getEditorDocumentLines(textDocument);
 		result.code.additionLines = realignAdditionHastLines(previousAdditionLines, diff.additionLines, result.code.additionLines, textDocument);
 		if (diff.additionLines.length <= 1 && diff.additionLines.join("") === "") {
-			Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
+			this.applyRecomputePreservingSessionType(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
 			result.code.additionLines[0] = createPlainAdditionLineElement(0, textDocument.getLineText(0));
-			this.markEditSessionPass(diff);
 		} else if (this.editSessionActive) this.applySessionDocumentChange(diff);
 		else Object.assign(diff, recomputeDiffHunksForEdit(diff, this.options.parseDiffOptions));
-		this.renderCache.isDirty = true;
+		if (pendingStructuralRows != null) {
+			for (const [line, row] of pendingStructuralRows) if (line < result.code.additionLines.length) result.code.additionLines[line] = row;
+		}
+		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);
+			this.applyRecomputePreservingSessionType(diff, recomputeTopAlignedAdditionDiff(diff, rawLines, parseDiffOptions));
 			return;
 		}
 		this.applyExpansionRemap(rebuildSessionHunks(diff, parseDiffOptions));
 	}
+	applyRecomputePreservingSessionType(diff, update) {
+		const sessionType = this.editSessionActive ? diff.type : void 0;
+		Object.assign(diff, update);
+		if (sessionType != null) diff.type = sessionType;
+		this.markEditSessionPass(diff);
+	}
 	markEditSessionPass(diff) {
 		if (!this.editSessionActive) return;
 		diff.editSessionDirty = true;
@@ -354,6 +395,7 @@ var DiffHunksRenderer = class {
 		if (cache != null && !areDiffRenderOptionsEqual(options, cache.options)) cache = void 0;
 		this.renderCache ??= {
 			diff,
+			hydrated: true,
 			highlighted: !massiveDiff && !isDiffPlainText(diff),
 			options,
 			result: massiveDiff ? void 0 : cache?.result,
@@ -410,17 +452,42 @@ var DiffHunksRenderer = class {
 			forceHighlight: false
 		};
 	}
-	renderDiff(diff = this.renderCache?.diff, renderRange = DEFAULT_RENDER_RANGE) {
-		if (diff == null) return;
+	/**
+	* Returns the diff that the next synchronous render can commit without
+	* changing the renderer's current diff or render cache. Components use this
+	* to prepare state that must match the following DOM render.
+	*/
+	getDiffForNextRender(diff) {
+		const { options } = this.getRenderOptions(diff);
+		if (this.getReadyRenderResult(diff, options) != null) return diff;
+		if (this.renderCache == null) return diff;
+		if (areDiffTargetsEqual(this.renderCache.diff, diff)) return this.renderCache.diff;
+		const forcePlainText = !(diff.additionLines.length > 0 || diff.deletionLines.length > 0) || isDiffPlainText(diff) || isDiffMassive(diff, this.getTokenizeMaxLength());
+		return this.canRenderDiff(diff, options, forcePlainText) ? diff : this.renderCache.diff;
+	}
+	canRenderDiff(diff, options, forcePlainText) {
+		const { renderCache } = this;
+		if (renderCache == null || areDiffTargetsEqual(renderCache.diff, diff)) return true;
+		if (forcePlainText) return renderCache.result == null && renderCache.hydrated !== true || this.workerManager?.isWorkingPool() === true || this.highlighter != null && areThemesAttached(options.theme);
+		if (renderCache.result == null && renderCache.hydrated !== true) return true;
+		if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) return !renderCache.highlighted;
+		return this.highlighter != null && areThemesAttached(options.theme);
+	}
+	renderDiff(diff = this.diff, renderRange = DEFAULT_RENDER_RANGE) {
+		this.diff = diff;
+		if (diff == null) {
+			this.pendingHighlightResult = void 0;
+			return;
+		}
 		const { expandUnchanged, collapsedContextThreshold } = this.getOptionsWithDefaults();
 		let { options, forceHighlight } = this.getRenderOptions(diff);
-		const cache = this.getMatchingWorkerResultCache(diff, options);
-		if (cache != null && !this.hasHighlightedRenderCache(diff, options)) {
+		const readyResult = this.getReadyRenderResult(diff, options);
+		this.pendingHighlightResult = void 0;
+		if (readyResult != null) {
 			this.renderCache = {
+				...readyResult,
 				diff,
-				highlighted: true,
-				renderRange: void 0,
-				...cache
+				renderRange: void 0
 			};
 			forceHighlight = false;
 		}
@@ -433,12 +500,12 @@ var DiffHunksRenderer = class {
 		};
 		const hasContent = diff.additionLines.length > 0 || diff.deletionLines.length > 0;
 		const forcePlainText = !hasContent || isDiffPlainText(diff) || isDiffMassive(diff, this.getTokenizeMaxLength());
+		const canRenderDiff = this.canRenderDiff(diff, options, forcePlainText);
 		const newContent = !areDiffTargetsEqual(diff, this.renderCache.diff);
 		const newRenderRange = !areRenderRangesEqual(this.renderCache.renderRange, renderRange);
 		if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) {
-			const highlightPending = this.renderCache.result == null && this.renderCache.highlighted && !forcePlainText && !newContent && isDefaultRenderRange(renderRange);
-			if (highlightPending) this.renderCache.highlightPending = true;
-			if (!highlightPending && (forcePlainText || this.renderCache.result == null || !this.renderCache.highlighted && (newContent || newRenderRange))) {
+			const preserveHydratedContent = this.renderCache.result == null && this.renderCache.highlighted && !forcePlainText && !newContent && isDefaultRenderRange(renderRange);
+			if (canRenderDiff && !preserveHydratedContent && (forcePlainText || this.renderCache.result == null || !this.renderCache.highlighted && (newContent || newRenderRange))) {
 				this.renderCache.diff = diff;
 				this.renderCache.options = options;
 				this.renderCache.highlighted = false;
@@ -448,10 +515,11 @@ var DiffHunksRenderer = class {
 			if (!forcePlainText && hasContent && (!this.renderCache.highlighted || forceHighlight)) this.workerManager.highlightDiffAST(this, diff);
 		} else {
 			this.computedLang = diff.lang ?? getFiletypeFromFileName(diff.name);
+			this.highlighter ??= getHighlighterIfLoaded();
 			const hasThemes = this.highlighter != null && areThemesAttached(options.theme);
 			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)) {
+			if (canRenderDiff && this.highlighter != null && hasThemes && (forceHighlight || forcePlainText || !this.renderCache.highlighted && canHighlight || this.renderCache.result == null)) {
 				const { result, options } = this.renderDiffWithHighlighter(diff, this.highlighter, forcePlainText || !hasLangs);
 				this.renderCache = {
 					diff,
@@ -462,13 +530,13 @@ var DiffHunksRenderer = class {
 				};
 			}
 			if (!hasThemes || !forcePlainText && !hasLangs) this.asyncHighlight(diff).then(({ result, options }) => {
-				if (this.renderCache != null) this.renderCache.highlighted = false;
 				this.applyHighlightResult(diff, result, options, !forcePlainText);
 			});
 		}
 		return this.renderCache.result != null ? this.processDiffResult(this.renderCache.diff, renderRange, this.renderCache.result) : void 0;
 	}
 	async asyncRender(diff, renderRange = DEFAULT_RENDER_RANGE) {
+		this.diff = diff;
 		const { result } = await this.asyncHighlight(diff);
 		return this.processDiffResult(diff, renderRange, result);
 	}
@@ -527,16 +595,16 @@ var DiffHunksRenderer = class {
 		this.applyHighlightResult(diff, result, options, highlighted);
 	}
 	applyHighlightResult(diff, result, options, highlighted = true) {
-		if (this.renderCache == null) return;
-		const triggerRenderUpdate = this.renderCache.highlightPending === true || !this.renderCache.highlighted || !areDiffRenderOptionsEqual(this.renderCache.options, options) || !areDiffTargetsEqual(this.renderCache.diff, diff);
-		this.renderCache = {
-			diff,
+		const { diff: currentDiff, renderCache } = this;
+		if (currentDiff == null || renderCache == null || !areDiffTargetsEqual(currentDiff, diff) || !areDiffRenderOptionsEqual(options, this.getRenderOptions(currentDiff).options)) return;
+		if (!(renderCache.result == null || !renderCache.highlighted || !areDiffRenderOptionsEqual(renderCache.options, options) || !areDiffTargetsEqual(renderCache.diff, currentDiff))) return;
+		this.pendingHighlightResult = {
+			diff: currentDiff,
 			options,
 			highlighted,
-			result,
-			renderRange: void 0
+			result
 		};
-		if (triggerRenderUpdate) this.onRenderUpdate?.();
+		this.onRenderUpdate?.();
 	}
 	getMatchingWorkerResultCache(diff, options) {
 		if (this.editSessionActive) return;
@@ -544,6 +612,17 @@ var DiffHunksRenderer = class {
 		if (cache == null || !areDiffRenderOptionsEqual(options, cache.options)) return;
 		return cache;
 	}
+	getReadyRenderResult(diff, options) {
+		const { pendingHighlightResult } = this;
+		if (pendingHighlightResult != null && areDiffTargetsEqual(pendingHighlightResult.diff, diff) && areDiffRenderOptionsEqual(pendingHighlightResult.options, options)) return pendingHighlightResult;
+		const workerCache = this.getMatchingWorkerResultCache(diff, options);
+		if (workerCache == null || this.hasHighlightedRenderCache(diff, options)) return;
+		return {
+			diff,
+			highlighted: true,
+			...workerCache
+		};
+	}
 	hasHighlightedRenderCache(diff, options) {
 		const { renderCache } = this;
 		return renderCache?.result != null && renderCache.highlighted && areDiffTargetsEqual(diff, renderCache.diff) && areDiffRenderOptionsEqual(options, renderCache.options);
@@ -557,7 +636,6 @@ var DiffHunksRenderer = class {
 	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;
@@ -821,6 +899,7 @@ var DiffHunksRenderer = class {
 		unifiedContentAST = unified && hasContent ? unifiedContentAST : void 0;
 		const preNode = this.createPreElement(deletionsContentAST != null && additionsContentAST != null, totalLines);
 		return {
+			fileDiff,
 			unifiedGutterAST: unified && hasContent ? context.unifiedGutterAST.children : void 0,
 			unifiedContentAST,
 			deletionsGutterAST: shouldIncludeDeletions && hasContent ? context.deletionsGutterAST.children : void 0,
@@ -831,7 +910,7 @@ var DiffHunksRenderer = class {
 			preNode,
 			themeStyles,
 			baseThemeType,
-			headerElement: !disableFileHeader ? this.renderHeader(this.diff) : void 0,
+			headerElement: !disableFileHeader ? this.renderHeader(fileDiff) : void 0,
 			totalLines,
 			rowCount: context.rowCount,
 			bufferBefore: renderRange.bufferBefore,
@@ -907,8 +986,8 @@ 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)) : [];
+		const deletionAnnotationNames = fileDiff.type !== "new" ? this.getAnnotationNames(getFileAnnotations(this.deletionAnnotations)) : [];
+		const additionAnnotationNames = fileDiff.type !== "deleted" ? this.getAnnotationNames(getFileAnnotations(this.additionAnnotations)) : [];
 		if (deletionAnnotationNames.length === 0 && additionAnnotationNames.length === 0) return;
 		const hunkIndex = -1;
 		const lineIndex = -1;
@@ -954,14 +1033,14 @@ var DiffHunksRenderer = class {
 			lineIndex,
 			annotations: []
 		};
-		if (deletionLineNumber != null) for (const anno of this.deletionAnnotations[deletionLineNumber] ?? []) deletionSpan.annotations.push(getLineAnnotationName(anno));
+		if (deletionLineNumber != null) for (const anno of this.deletionAnnotations[deletionLineNumber] ?? []) deletionSpan.annotations.push(this.annotationSlotName(anno));
 		const additionSpan = {
 			type: "annotation",
 			hunkIndex,
 			lineIndex,
 			annotations: []
 		};
-		if (additionLineNumber != null) for (const anno of this.additionAnnotations[additionLineNumber] ?? []) (type === "unified" ? deletionSpan : additionSpan).annotations.push(getLineAnnotationName(anno));
+		if (additionLineNumber != null) for (const anno of this.additionAnnotations[additionLineNumber] ?? []) (type === "unified" ? deletionSpan : additionSpan).annotations.push(this.annotationSlotName(anno));
 		if (type === "unified") {
 			if (deletionSpan.annotations.length > 0) return deletionSpan;
 			return;
@@ -972,6 +1051,9 @@ var DiffHunksRenderer = class {
 			additionSpan
 		};
 	}
+	getAnnotationNames(annotations) {
+		return annotations?.map((annotation) => this.annotationSlotName(annotation)) ?? [];
+	}
 	renderHeader(diff) {
 		const { headerRenderMode, stickyHeader } = this.getOptionsWithDefaults();
 		return createFileHeaderElement({
@@ -981,9 +1063,6 @@ 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${EN_PLURAL_RULES.select(lines) === "one" ? "" : "s"}`;
@@ -1143,7 +1222,6 @@ function realignAdditionHastLines(previousLines, nextLines, hastLines, textDocum
 	for (let index = 0; index < prefix; index++) realigned[index] = hastLines[index];
 	for (let offset = 0; offset < suffix; offset++) realigned[nextContentLength - 1 - offset] = hastLines[previousContentLength - 1 - offset];
 	if (previousContentLength < previousLines.length && nextContentLength < nextLines.length) realigned[nextLines.length - 1] = hastLines[previousLines.length - 1];
-	for (let index = previousLines.length; index < nextLines.length; index++) realigned[index] ??= hastLines[index];
 	for (let index = prefix; index < nextLines.length; index++) realigned[index] ??= createPlainAdditionLineElement(index, textDocument.getLineText(index));
 	return realigned;
 }
@@ -1167,26 +1245,11 @@ function createPlainAdditionLineElement(lineIndex, lineText, unifiedLineIndex =
 		}]
 	};
 }
-function getEditorDocumentLines(textDocument, previousLines) {
+function getEditorDocumentLines(textDocument) {
 	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);
-	}
+	for (let line = 0; line < textDocument.lineCount; line++) lines.push(textDocument.getLineText(line, true));
 	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;
 }