@pierre/diffs 1.2.12 → 1.3.0-beta.10

package/dist/components/FileDiff.js

@@ -1,9 +1,13 @@
-import { CUSTOM_HEADER_SLOT_ID, DEFAULT_THEMES, EMPTY_RENDER_RANGE, HEADER_METADATA_SLOT_ID, HEADER_PREFIX_SLOT_ID } from "../constants.js";
+import { CUSTOM_HEADER_SLOT_ID, DEFAULT_THEMES, EMPTY_RENDER_RANGE, HEADER_FILENAME_SUFFIX_SLOT_ID, HEADER_METADATA_SLOT_ID, HEADER_PREFIX_SLOT_ID } from "../constants.js";
+import { dequeueRender, queueRender } from "../managers/UniversalRenderingManager.js";
 import { areThemesEqual } from "../utils/areThemesEqual.js";
+import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
+import { getExpandedRegion, getNearestRenderableAdditionLine, getTrailingExpandedRegion, isAdditionLineRenderable } from "../utils/virtualDiffLayout.js";
+import { captureExpansionAnchors, finishEditSessionForDiff, rebuildExpansionFromAnchors } from "../utils/editSessionHunks.js";
 import { isStyleNode } from "../utils/isStyleNode.js";
+import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { InteractionManager, pluckInteractionOptions } from "../managers/InteractionManager.js";
 import { ResizeManager } from "../managers/ResizeManager.js";
-import { areFilesEqual } from "../utils/areFilesEqual.js";
 import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
 import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
 import { SVGSpriteSheet } from "../sprite.js";
@@ -18,8 +22,12 @@ import { upsertHostThemeStyle } from "../utils/hostTheme.js";
 import { prerenderHTMLIfNecessary } from "../utils/prerenderHTMLIfNecessary.js";
 import { setPreNodeProperties } from "../utils/setWrapperNodeProps.js";
 import "./web-components.js";
-import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
+import { awaitWithTimeout } from "../utils/awaitWithTimeout.js";
+import { getDiffFileInput } from "../utils/getDiffFileInput.js";
+import { hydratePartialDiff } from "../utils/hydratePartialDiff.js";
+import { iterateOverDiff } from "../utils/iterateOverDiff.js";
 import { ScrollSyncManager } from "../managers/ScrollSyncManager.js";
+import { isDefaultRenderRange } from "../utils/isDefaultRenderRange.js";
 import { isDiffPlainText } from "../utils/isDiffPlainText.js";
 import { DiffHunksRenderer } from "../renderers/DiffHunksRenderer.js";
 import { areDiffLineAnnotationsEqual } from "../utils/areDiffLineAnnotationsEqual.js";
@@ -27,6 +35,9 @@ import { areHunkDataEqual } from "../utils/areHunkDataEqual.js";
 import { getDiffHunksRendererOptions } from "../utils/getDiffHunksRendererOptions.js";
 import { toHtml } from "hast-util-to-html";
 //#region src/components/FileDiff.ts
+function canHydrateDiff(fileDiff) {
+	return fileDiff.isPartial && (fileDiff.type === "change" || fileDiff.type === "rename-changed" || fileDiff.type === "rename-pure");
+}
 let instanceId = -1;
 var FileDiff = class {
 	options;
@@ -51,6 +62,7 @@ var FileDiff = class {
 	gutterUtilityContent;
 	headerElement;
 	headerPrefix;
+	headerFilenameSuffix;
 	headerMetadata;
 	headerCustom;
 	separatorCache = /* @__PURE__ */ new Map();
@@ -67,12 +79,16 @@ var FileDiff = class {
 	additionFile;
 	fileDiff;
 	renderRange;
+	pendingFiles;
 	appliedPreAttributes;
 	lastRenderedHeaderHTML;
 	cachedHeaderHTML;
 	lastRowCount;
 	mounted = false;
 	enabled = true;
+	editor;
+	refreshViewTimeout;
+	deferSetSelection;
 	constructor(options = { theme: DEFAULT_THEMES }, workerManager, isContainerManaged = false) {
 		this.options = options;
 		this.workerManager = workerManager;
@@ -94,11 +110,12 @@ var FileDiff = class {
 		return new DiffHunksRenderer(this.getHunksRendererOptions(options), this.handleHighlightRender, this.workerManager);
 	}
 	getLineIndex = (lineNumber, side = "additions") => {
-		if (this.fileDiff == null) return;
-		const lastHunk = this.fileDiff.hunks.at(-1);
+		const fileDiff = this.fileDiffCache;
+		if (fileDiff == null) return;
+		const lastHunk = fileDiff.hunks.at(-1);
 		let targetUnifiedIndex;
 		let targetSplitIndex;
-		hunkIterator: for (const hunk of this.fileDiff.hunks) {
+		hunkIterator: for (const hunk of fileDiff.hunks) {
 			let currentLineNumber = side === "deletions" ? hunk.deletionStart : hunk.additionStart;
 			const hunkCount = side === "deletions" ? hunk.deletionCount : hunk.additionCount;
 			let splitIndex = hunk.splitLineStart;
@@ -188,7 +205,8 @@ var FileDiff = class {
 		return true;
 	}
 	setSelectedLines(range, options) {
-		this.interactionManager.setSelection(range, options);
+		if (this.refreshViewTimeout != null) this.deferSetSelection = [range, options];
+		else this.interactionManager.setSelection(range, options);
 	}
 	flushManagers() {
 		if (!this.managersDirty || this.pre == null) {
@@ -197,12 +215,20 @@ var FileDiff = class {
 		}
 		const { diffStyle = "split", overflow = "scroll" } = this.options;
 		this.interactionManager.setup(this.pre);
-		this.resizeManager.setup(this.pre, overflow === "wrap");
+		this.resizeManager.setup(this.pre, {
+			disableAnnotations: overflow === "wrap",
+			columnVariables: this.shouldApplyColumnVariables(overflow) ? "apply" : "measure"
+		});
 		if (overflow === "scroll" && diffStyle === "split") this.scrollSyncManager.setup(this.pre, this.codeDeletions, this.codeAdditions);
 		else this.scrollSyncManager.cleanUp();
 		this.managersDirty = false;
 	}
+	shouldApplyColumnVariables(overflow) {
+		if (typeof this.options.hunkSeparators === "function") return true;
+		return overflow === "scroll" && (this.lineAnnotations.length > 0 || this.pre?.hasAttribute("data-has-merge-conflict") === true);
+	}
 	cleanUp(recycle = false) {
+		dequeueRender(this.handleEditSessionRender);
 		this.emitPostRender(true);
 		this.resizeManager.cleanUp();
 		this.interactionManager.cleanUp();
@@ -210,6 +236,7 @@ var FileDiff = class {
 		this.managersDirty = false;
 		this.workerManager?.unsubscribeToThemeChanges(this);
 		this.renderRange = void 0;
+		this.pendingFiles = void 0;
 		if (!this.isContainerManaged) this.fileContainer?.remove();
 		this.fileContainer = void 0;
 		this.mounted = false;
@@ -220,16 +247,21 @@ var FileDiff = class {
 		this.codeUnified = void 0;
 		this.codeDeletions = void 0;
 		this.codeAdditions = void 0;
+		this.bufferBefore?.remove();
 		this.bufferBefore = void 0;
+		this.bufferAfter?.remove();
 		this.bufferAfter = void 0;
 		this.appliedPreAttributes = void 0;
 		this.headerElement = void 0;
 		this.headerPrefix = void 0;
+		this.headerFilenameSuffix = void 0;
 		this.headerMetadata = void 0;
 		this.headerCustom = void 0;
+		this.placeHolder?.remove();
 		this.placeHolder = void 0;
 		this.lastRenderedHeaderHTML = void 0;
 		if (!recycle) this.cachedHeaderHTML = void 0;
+		this.errorWrapper?.remove();
 		this.errorWrapper = void 0;
 		this.spriteSVG = void 0;
 		this.lastRowCount = void 0;
@@ -247,13 +279,23 @@ var FileDiff = class {
 			this.additionFile = void 0;
 		}
 		this.enabled = false;
+		this.editor?.cleanUp(recycle);
+		this.editor = void 0;
+		if (this.refreshViewTimeout != null) {
+			clearTimeout(this.refreshViewTimeout);
+			this.refreshViewTimeout = void 0;
+		}
 	}
 	virtualizedSetup() {
 		this.enabled = true;
 		this.workerManager?.subscribeToThemeChanges(this);
 	}
-	hydrate(props) {
-		const { fileContainer, prerenderedHTML, preventEmit = false, lineAnnotations, oldFile, newFile, fileDiff } = props;
+	hydrate({ fileContainer, prerenderedHTML, preventEmit = false, lineAnnotations, fileDiff, ...fileInputProps }) {
+		if (!this.enabled) throw new Error("FileDiff.hydrate: attempting to call hydrate after cleaned up");
+		if (this.fileContainer != null) throw new Error("FileDiff.hydrate: hydrate can only be called before the instance has rendered or hydrated");
+		const fileInput = getDiffFileInput(fileInputProps, "FileDiff.hydrate");
+		const oldFile = fileInput?.oldFile;
+		const newFile = fileInput?.newFile;
 		this.hydrateElements(fileContainer, prerenderedHTML);
 		if (shouldRenderCode(this.pre, hasDiffContent({
 			fileDiff,
@@ -264,14 +306,16 @@ var FileDiff = class {
 			oldFile,
 			newFile
 		}), this.options.disableFileHeader)) this.render({
-			...props,
+			...fileInputProps,
+			fileContainer,
+			lineAnnotations,
+			fileDiff,
 			preventEmit: true
 		});
 		else this.hydrationSetup({
 			fileDiff,
-			oldFile,
-			newFile,
-			lineAnnotations
+			lineAnnotations,
+			...fileInput
 		});
 		if (!preventEmit) this.emitPostRender();
 	}
@@ -319,7 +363,7 @@ var FileDiff = class {
 		this.lineAnnotations = lineAnnotations ?? this.lineAnnotations;
 		this.additionFile = newFile;
 		this.deletionFile = oldFile;
-		this.fileDiff = fileDiff ?? (oldFile != null && newFile != null ? parseDiffFromFile(oldFile, newFile, this.options.parseDiffOptions) : void 0);
+		this.fileDiff = fileDiff ?? (oldFile !== void 0 && newFile !== void 0 ? parseDiffFromFile(oldFile, newFile, this.options.parseDiffOptions) : void 0);
 		if (this.pre == null) return;
 		this.syncInteractionOptions();
 		this.hunksRenderer.hydrate(this.fileDiff);
@@ -345,29 +389,74 @@ var FileDiff = class {
 	};
 	expandHunk = (hunkIndex, direction, expansionLineCountOverride) => {
 		this.hunksRenderer.expandHunk(hunkIndex, direction, expansionLineCountOverride);
+		this.loadFilesIfNecessary();
 		this.rerender();
 	};
-	render({ oldFile, newFile, fileDiff, deferManagers = false, forceRender = false, preventEmit = false, lineAnnotations, fileContainer, containerWrapper, renderRange }) {
+	loadFilesIfNecessary() {
+		const { fileDiff, options: { loadDiffFiles } } = this;
+		if (fileDiff == null || loadDiffFiles == null || !canHydrateDiff(fileDiff) || this.pendingFiles?.fileDiff === fileDiff) return;
+		this.pendingFiles = {
+			fileDiff,
+			promise: this.loadFilesForDiff(fileDiff, loadDiffFiles)
+		};
+	}
+	async loadFilesForDiff(fileDiff, loadDiffFiles) {
+		try {
+			const files = await loadDiffFiles(fileDiff);
+			if (!this.enabled || this.fileDiff !== fileDiff) return;
+			await this.handleFilesLoaded(fileDiff, files);
+		} catch (error) {
+			if (this.options.disableErrorHandling === true) throw error;
+			console.error(error);
+		} finally {
+			if (this.pendingFiles?.fileDiff === fileDiff) this.pendingFiles = void 0;
+		}
+	}
+	async handleFilesLoaded(expectedDiff, files) {
+		if (this.fileDiff !== expectedDiff || !expectedDiff.isPartial) return;
+		hydratePartialDiff("merge", expectedDiff, files);
+		this.setHydratedState(files);
+		await awaitWithTimeout(() => this.primeHighlightCache(expectedDiff));
+		if (!this.enabled || this.fileDiff !== expectedDiff) return;
+		this.rerender();
+	}
+	setHydratedState(files) {
+		this.deletionFile = files.oldFile;
+		this.additionFile = files.newFile;
+		this.workerManager?.cleanUpTasks(this.hunksRenderer);
+		this.hunksRenderer.clearRenderCache();
+	}
+	render({ fileDiff, deferManagers = false, forceRender = false, preventEmit = false, lineAnnotations, fileContainer, containerWrapper, renderRange, ...fileInputProps }) {
+		const fileInput = getDiffFileInput(fileInputProps, "FileDiff.render");
+		const oldFile = fileInput?.oldFile;
+		const newFile = fileInput?.newFile;
 		if (!this.enabled) throw new Error("FileDiff.render: attempting to call render after cleaned up");
-		const { collapsed = false, themeType = "system" } = this.options;
+		if (fileDiff != null && fileDiff.cacheKey === void 0) fileDiff.cacheKey = fileDiff.prevName != null ? fileDiff.prevName + ":" + fileDiff.name : fileDiff.name;
+		this.editor?.__postponeBgTokenizeToNextFrame();
+		const { collapsed = false, themeType = "system", expandUnchanged = false } = this.options;
 		const nextRenderRange = collapsed ? void 0 : renderRange;
 		const themeChanged = this.hasThemeChanged();
-		const filesDidChange = oldFile != null && newFile != null && (!areFilesEqual(oldFile, this.deletionFile) || !areFilesEqual(newFile, this.additionFile));
+		const hasFileInput = fileInput != null;
+		const filesDidChange = hasFileInput && (!areOptionalFilesEqual(oldFile, this.deletionFile) || !areOptionalFilesEqual(newFile, this.additionFile));
 		let diffDidChange = fileDiff != null && fileDiff !== this.fileDiff;
 		const annotationsChanged = lineAnnotations != null && (lineAnnotations.length > 0 || this.lineAnnotations.length > 0) ? lineAnnotations !== this.lineAnnotations : false;
 		if (!collapsed && areRenderRangesEqual(nextRenderRange, this.renderRange) && !forceRender && !annotationsChanged && !themeChanged && (fileDiff != null && fileDiff === this.fileDiff || fileDiff == null && !filesDidChange)) return this.applyCachedThemeState(themeType);
+		let nextParsedFileDiff;
+		if (fileDiff == null && hasFileInput && (filesDidChange || this.fileDiff == null)) nextParsedFileDiff = parseDiffFromFile(fileInput.oldFile, fileInput.newFile, this.options.parseDiffOptions);
 		const { renderRange: previousRenderRange } = this;
 		this.renderRange = nextRenderRange;
 		this.deletionFile = oldFile;
 		this.additionFile = newFile;
 		if (fileDiff != null) this.fileDiff = fileDiff;
-		else if (oldFile != null && newFile != null && filesDidChange) {
+		else if (nextParsedFileDiff != null) {
 			diffDidChange = true;
-			this.fileDiff = parseDiffFromFile(oldFile, newFile, this.options.parseDiffOptions);
+			this.fileDiff = nextParsedFileDiff;
 		}
 		if (diffDidChange) this.cachedHeaderHTML = void 0;
 		if (lineAnnotations != null) this.setLineAnnotations(lineAnnotations);
 		if (this.fileDiff == null) return false;
+		if (this.fileDiff.editSessionDirty === true && this.shouldSelfHealEditSession()) finishEditSessionForDiff(this.fileDiff, this.options.parseDiffOptions);
+		if (expandUnchanged) this.loadFilesIfNecessary();
 		this.hunksRenderer.setOptions(this.getHunksRendererOptions(this.options));
 		this.syncInteractionOptions();
 		this.hunksRenderer.setLineAnnotations(this.lineAnnotations);
@@ -425,6 +514,7 @@ var FileDiff = class {
 			this.renderGutterUtility();
 			this.managersDirty = true;
 			if (!deferManagers) this.flushManagers();
+			if (this.editor != null) this.syncRenderViewToEditor();
 		} catch (error) {
 			if (disableErrorHandling) throw error;
 			console.error(error);
@@ -447,6 +537,198 @@ var FileDiff = class {
 		this.mounted = true;
 		onPostRender?.(fileContainer, this, phase);
 	}
+	get fileDiffCache() {
+		return this.hunksRenderer.diffCache ?? this.fileDiff;
+	}
+	syncRenderViewToEditor() {
+		const editor = this.editor;
+		const fileContainer = this.fileContainer;
+		const fileDiff = this.fileDiffCache;
+		const lineAnnotations = this.lineAnnotations;
+		const renderRange = this.computeEditorRenderRange(this.renderRange);
+		if (editor != null && fileContainer != null && fileDiff != null && !fileDiff.isPartial) this.hunksRenderer.initializeHighlighter().then((highlighter) => {
+			if (!this.enabled || this.editor !== editor || this.fileContainer !== fileContainer || this.fileDiffCache !== fileDiff) return;
+			editor.__syncRenderView(highlighter, fileContainer, fileDiff, lineAnnotations, renderRange);
+		});
+	}
+	computeEditorRenderRange(renderRange) {
+		const fileDiff = this.fileDiffCache;
+		if (renderRange == null || fileDiff == null || isDefaultRenderRange(renderRange)) return renderRange;
+		const { diffStyle = "split", expandUnchanged = false, collapsedContextThreshold = 1 } = this.options;
+		let firstLineNumber;
+		let lastLineNumber;
+		iterateOverDiff({
+			diff: fileDiff,
+			diffStyle,
+			startingLine: renderRange.startingLine,
+			totalLines: renderRange.totalLines,
+			expandedHunks: expandUnchanged ? true : this.hunksRenderer.getExpandedHunksMap(),
+			collapsedContextThreshold,
+			callback: ({ additionLine }) => {
+				if (additionLine != null) {
+					firstLineNumber ??= additionLine.lineNumber;
+					lastLineNumber = additionLine.lineNumber;
+				}
+			}
+		});
+		if (firstLineNumber == null || lastLineNumber == null) return {
+			...renderRange,
+			startingLine: 0,
+			totalLines: 0
+		};
+		return {
+			...renderRange,
+			startingLine: firstLineNumber - 1,
+			totalLines: lastLineNumber - firstLineNumber + 1
+		};
+	}
+	attachEditor(editor) {
+		this.editor?.cleanUp();
+		this.editor = editor;
+		this.interactionManager.setEditorAttached(true);
+		if (this.type === "file-diff") this.hunksRenderer.beginEditSession(this.fileDiffCache);
+		if (this.fileDiff?.isPartial === true) this.loadFilesIfNecessary();
+		this.syncRenderViewToEditor();
+		return (recycle) => {
+			this.editor = void 0;
+			this.interactionManager.setEditorAttached(false);
+			if (recycle !== true) this.finishEditSession();
+		};
+	}
+	finishEditSession() {
+		this.hunksRenderer.endEditSession();
+		this.completeEditSession();
+	}
+	/**
+	* Run the genuine session-end recompute: restore recompute-shaped hunks (a
+	* context-only region collapses away, boundaries re-derive), preserve
+	* expansion state best-effort via old-side anchors, and repaint through
+	* the session render path — which also invalidates virtualized layout,
+	* since nothing else does at exit now that editing does not flip
+	* expandUnchanged. Marker-guarded and idempotent; CodeView also calls this
+	* when reaping a session whose detach closure was consumed by a recycle.
+	* Safe on a cleaned-up instance: the recompute is pure metadata work and
+	* the deferred rerender is enabled-guarded. Returns true when a recompute
+	* ran.
+	*/
+	completeEditSession() {
+		const fileDiff = this.fileDiffCache;
+		if (fileDiff == null || fileDiff.editSessionDirty !== true) return false;
+		const { collapsedContextThreshold = 1 } = this.options;
+		const anchors = captureExpansionAnchors(fileDiff, this.hunksRenderer.getExpandedHunksMap(), collapsedContextThreshold);
+		finishEditSessionForDiff(fileDiff, this.options.parseDiffOptions);
+		this.hunksRenderer.setExpandedHunksMap(rebuildExpansionFromAnchors(fileDiff, anchors));
+		this.escalateEditSessionRender();
+		return true;
+	}
+	applyDocumentChange(textDocument, newLineAnnotations) {
+		this.hunksRenderer.applyDocumentChange(textDocument);
+		const fileDiff = this.hunksRenderer.diffCache;
+		if (fileDiff != null) {
+			const cacheKey = this.fileDiff?.cacheKey;
+			if (cacheKey != null && fileDiff.cacheKey == null) fileDiff.cacheKey = cacheKey;
+			this.fileDiff = fileDiff;
+		}
+		if (newLineAnnotations !== void 0 && newLineAnnotations !== this.lineAnnotations) {
+			this.setLineAnnotations(newLineAnnotations);
+			this.hunksRenderer.setLineAnnotations(this.lineAnnotations);
+			this.renderAnnotations();
+		}
+		this.rerender();
+		this.interactionManager.setSelectionDirty();
+	}
+	updateRenderCache(dirtyLines, themeType, shouldRefreshView, lineCountChangeInFlight = false) {
+		if (this.hunksRenderer.updateRenderCache(dirtyLines, themeType, lineCountChangeInFlight)) {
+			if (this.refreshViewTimeout != null) {
+				clearTimeout(this.refreshViewTimeout);
+				this.refreshViewTimeout = void 0;
+			}
+			this.escalateEditSessionRender();
+			return;
+		}
+		if (shouldRefreshView) {
+			if (this.refreshViewTimeout != null) clearTimeout(this.refreshViewTimeout);
+			this.refreshViewTimeout = setTimeout(() => {
+				this.refreshViewTimeout = void 0;
+				if (this.options.diffStyle === "split") this.refreshSplitDiffView();
+				else this.refreshUnifiedDiffView();
+				if (this.deferSetSelection != null) {
+					this.interactionManager.setSelection(...this.deferSetSelection);
+					this.deferSetSelection = void 0;
+				}
+			}, 150);
+		}
+	}
+	isLineRenderable(lineNumber) {
+		const fileDiff = this.fileDiffCache;
+		if (fileDiff == null) return true;
+		const { expandUnchanged = false, collapsedContextThreshold = 1 } = this.options;
+		return isAdditionLineRenderable({
+			fileDiff,
+			lineNumber,
+			expandedHunks: expandUnchanged ? true : this.hunksRenderer.getExpandedHunksMap(),
+			collapsedContextThreshold
+		});
+	}
+	getNearestRenderableLine(lineNumber, direction) {
+		const fileDiff = this.fileDiffCache;
+		if (fileDiff == null) return lineNumber;
+		const { expandUnchanged = false, collapsedContextThreshold = 1 } = this.options;
+		return getNearestRenderableAdditionLine({
+			fileDiff,
+			lineNumber,
+			direction,
+			expandedHunks: expandUnchanged ? true : this.hunksRenderer.getExpandedHunksMap(),
+			collapsedContextThreshold
+		});
+	}
+	revealLine(lineNumber) {
+		const fileDiff = this.fileDiffCache;
+		const { expandUnchanged = false, collapsedContextThreshold = 1, expansionLineCount = 100 } = this.options;
+		if (fileDiff == null || fileDiff.isPartial || expandUnchanged) return false;
+		const expandedHunks = this.hunksRenderer.getExpandedHunksMap();
+		for (const [hunkIndex, hunk] of fileDiff.hunks.entries()) {
+			if (lineNumber < hunk.additionStart) {
+				const region = getExpandedRegion({
+					isPartial: fileDiff.isPartial,
+					rangeSize: hunk.collapsedBefore,
+					expandedHunks,
+					hunkIndex,
+					collapsedContextThreshold
+				});
+				const gapStart = hunk.additionStart - region.rangeSize;
+				if (region.renderAll || lineNumber < gapStart + region.fromStart || lineNumber >= hunk.additionStart - region.fromEnd) return false;
+				const fromStartDistance = lineNumber - (gapStart + region.fromStart) + 1;
+				const fromEndDistance = hunk.additionStart - region.fromEnd - lineNumber;
+				if (fromStartDistance <= fromEndDistance) this.expandHunk(hunkIndex, "up", fromStartDistance + expansionLineCount);
+				else this.expandHunk(hunkIndex, "down", fromEndDistance + expansionLineCount);
+				return true;
+			}
+			if (lineNumber < hunk.additionStart + hunk.additionCount) return false;
+		}
+		const trailingRegion = getTrailingExpandedRegion({
+			fileDiff,
+			hunkIndex: fileDiff.hunks.length - 1,
+			expandedHunks,
+			collapsedContextThreshold,
+			errorPrefix: "FileDiff.revealLine"
+		});
+		if (trailingRegion == null || trailingRegion.renderAll) return false;
+		const lastHunk = fileDiff.hunks[fileDiff.hunks.length - 1];
+		const trailingStart = lastHunk.additionStart + lastHunk.additionCount;
+		if (lineNumber < trailingStart + trailingRegion.fromStart || lineNumber >= trailingStart + trailingRegion.rangeSize) return false;
+		this.expandHunk(fileDiff.hunks.length, "up", lineNumber - (trailingStart + trailingRegion.fromStart) + 1 + expansionLineCount);
+		return true;
+	}
+	shouldSelfHealEditSession() {
+		return this.editor == null;
+	}
+	escalateEditSessionRender() {
+		queueRender(this.handleEditSessionRender);
+	}
+	handleEditSessionRender = () => {
+		this.rerender();
+	};
 	removeRenderedCode() {
 		this.resizeManager.cleanUp();
 		this.scrollSyncManager.cleanUp();
@@ -487,12 +769,14 @@ var FileDiff = class {
 		this.placeHolder.style.setProperty("height", `${height}px`);
 		return true;
 	}
-	primeHighlightCache() {
-		const { fileDiff, workerManager } = this;
-		if (fileDiff == null || workerManager == null || isDiffPlainText(fileDiff)) return;
+	async primeHighlightCache(fileDiff = this.fileDiff) {
+		const { workerManager } = this;
+		if (fileDiff == null || workerManager == null || !workerManager.isWorkingPool() || fileDiff.cacheKey == null || isDiffPlainText(fileDiff)) return;
 		const tokenizeMaxLength = this.options.tokenizeMaxLength ?? 1e5;
 		if (Math.max(fileDiff.additionLines.length, fileDiff.deletionLines.length) > tokenizeMaxLength) return;
-		workerManager.primeDiffHighlightCache(fileDiff);
+		await workerManager.primeDiffHighlightCache(fileDiff).catch((error) => {
+			console.error(error);
+		});
 	}
 	cleanChildNodes() {
 		this.resizeManager.cleanUp();
@@ -507,6 +791,7 @@ var FileDiff = class {
 		this.errorWrapper?.remove();
 		this.headerElement?.remove();
 		this.headerPrefix?.remove();
+		this.headerFilenameSuffix?.remove();
 		this.headerMetadata?.remove();
 		this.headerCustom?.remove();
 		this.pre?.remove();
@@ -521,6 +806,7 @@ var FileDiff = class {
 		this.errorWrapper = void 0;
 		this.headerElement = void 0;
 		this.headerPrefix = void 0;
+		this.headerFilenameSuffix = void 0;
 		this.headerMetadata = void 0;
 		this.headerCustom = void 0;
 		this.pre = void 0;
@@ -698,28 +984,34 @@ var FileDiff = class {
 			this.lastRenderedHeaderHTML = headerHTML;
 		}
 		if (this.isContainerManaged || fileDiff == null) return;
-		const { renderCustomHeader, renderHeaderPrefix, renderHeaderMetadata } = this.options;
+		const { renderCustomHeader, renderHeaderPrefix, renderHeaderFilenameSuffix, renderHeaderMetadata } = this.options;
 		if (renderCustomHeader != null) {
 			const content = renderCustomHeader(fileDiff) ?? void 0;
 			this.headerCustom = this.upsertHeaderSlotElement(container, this.headerCustom, CUSTOM_HEADER_SLOT_ID, content);
 			this.headerPrefix?.remove();
+			this.headerFilenameSuffix?.remove();
 			this.headerMetadata?.remove();
 			this.headerPrefix = void 0;
+			this.headerFilenameSuffix = void 0;
 			this.headerMetadata = void 0;
 			return;
 		}
 		const prefix = renderHeaderPrefix?.(fileDiff) ?? void 0;
+		const suffix = renderHeaderFilenameSuffix?.(fileDiff) ?? void 0;
 		const content = renderHeaderMetadata?.(fileDiff) ?? void 0;
 		this.headerPrefix = this.upsertHeaderSlotElement(container, this.headerPrefix, HEADER_PREFIX_SLOT_ID, prefix);
+		this.headerFilenameSuffix = this.upsertHeaderSlotElement(container, this.headerFilenameSuffix, HEADER_FILENAME_SUFFIX_SLOT_ID, suffix);
 		this.headerMetadata = this.upsertHeaderSlotElement(container, this.headerMetadata, HEADER_METADATA_SLOT_ID, content);
 		this.headerCustom?.remove();
 		this.headerCustom = void 0;
 	}
 	clearHeaderSlots() {
 		this.headerPrefix?.remove();
+		this.headerFilenameSuffix?.remove();
 		this.headerMetadata?.remove();
 		this.headerCustom?.remove();
 		this.headerPrefix = void 0;
+		this.headerFilenameSuffix = void 0;
 		this.headerMetadata = void 0;
 		this.headerCustom = void 0;
 	}
@@ -936,6 +1228,45 @@ var FileDiff = class {
 			this.renderPartialColumn(columns[1], additionsAST, insertPosition);
 		} else throw new Error("FileDiff.insertPartialHTML: Invalid argument composition");
 	}
+	refreshSplitDiffView() {
+		if (this.options.diffStyle !== "split") return;
+		const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, this.renderRange);
+		if (hunksResult == null) return;
+		const columns = this.getCodeColumns("split", this.codeUnified, this.codeDeletions, this.codeAdditions);
+		if (!Array.isArray(columns)) return;
+		const applyLineType = (type, column) => {
+			if (column == null) return;
+			const ast = this.hunksRenderer.renderCodeAST(type, hunksResult);
+			const gutterChildren = getElementChildren(ast?.[0]);
+			const contentChildren = getElementChildren(ast?.[1]);
+			for (const [el, astChildren] of [[column.gutter, gutterChildren], [column.content, contentChildren]]) if (astChildren != null && el.childElementCount === astChildren.length) for (let i = 0; i < astChildren.length; i++) {
+				const gutterElement = el.children[i];
+				const lineType = astChildren[i].properties["data-line-type"];
+				if (lineType != null && gutterElement.dataset.lineType !== lineType) gutterElement.dataset.lineType = lineType;
+			}
+		};
+		applyLineType("deletions", columns[0]);
+		applyLineType("additions", columns[1]);
+	}
+	refreshUnifiedDiffView() {
+		if (this.options.diffStyle !== "unified") return;
+		const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, this.renderRange);
+		if (hunksResult == null) return;
+		const columns = this.getCodeColumns("unified", this.codeUnified, this.codeDeletions, this.codeAdditions);
+		if (columns == null || Array.isArray(columns)) return;
+		const ast = this.hunksRenderer.renderCodeAST("unified", hunksResult);
+		const gutterChildren = getElementChildren(ast?.[0]);
+		const contentChildren = getElementChildren(ast?.[1]);
+		for (const [el, astChildren] of [[columns.gutter, gutterChildren], [columns.content, contentChildren]]) if (astChildren != null) el.innerHTML = toHtml(astChildren);
+		if (hunksResult.rowCount !== this.lastRowCount) {
+			this.applyRowSpan("unified", columns, hunksResult.rowCount);
+			this.lastRowCount = hunksResult.rowCount;
+		}
+		this.renderSeparators(hunksResult.hunkData);
+		this.managersDirty = true;
+		this.flushManagers();
+		this.syncRenderViewToEditor();
+	}
 	renderPartialColumn(column, ast, insertPosition) {
 		if (column == null || ast == null) return;
 		const gutterChildren = getElementChildren(ast[0]);
@@ -1135,6 +1466,9 @@ var FileDiff = class {
 			return deletions != null || additions != null ? [deletions, additions] : void 0;
 		}
 	}
+	updateBuffers(renderRange) {
+		if (this.pre != null) this.applyBuffers(this.pre, renderRange);
+	}
 	applyBuffers(pre, renderRange) {
 		if (renderRange == null || this.shouldDisableVirtualizationBuffers()) {
 			if (this.bufferBefore != null) {
@@ -1215,6 +1549,10 @@ var FileDiff = class {
 		this.errorWrapper = void 0;
 	}
 };
+function areOptionalFilesEqual(fileA, fileB) {
+	if (fileA == null || fileB == null) return fileA == null && fileB == null;
+	return areFilesEqual(fileA, fileB);
+}
 function hasDiffContent({ fileDiff, oldFile, newFile }) {
 	return fileDiff != null && fileDiff.hunks.length > 0 || oldFile != null || newFile != null;
 }