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

package/dist/components/FileDiff.js

@@ -2,6 +2,7 @@ import { DEFAULT_THEMES, DIFFS_TAG_NAME, HEADER_METADATA_SLOT_ID, UNSAFE_CSS_ATT
 import { LineSelectionManager, pluckLineSelectionOptions } from "../managers/LineSelectionManager.js";
 import { MouseEventManager, pluckMouseEventOptions } from "../managers/MouseEventManager.js";
 import { ResizeManager } from "../managers/ResizeManager.js";
+import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
 import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
 import { SVGSpriteSheet } from "../sprite.js";
 import { areFilesEqual } from "../utils/areFilesEqual.js";
@@ -15,7 +16,6 @@ import { prerenderHTMLIfNecessary } from "../utils/prerenderHTMLIfNecessary.js";
 import { setPreNodeProperties } from "../utils/setWrapperNodeProps.js";
 import { DiffsContainerLoaded } from "./web-components.js";
 import { ScrollSyncManager } from "../managers/ScrollSyncManager.js";
-import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
 import { DiffHunksRenderer } from "../renderers/DiffHunksRenderer.js";
 import { areDiffLineAnnotationsEqual } from "../utils/areDiffLineAnnotationsEqual.js";
 import { areHunkDataEqual } from "../utils/areHunkDataEqual.js";
@@ -33,12 +33,15 @@ var FileDiff = class {
 	codeUnified;
 	codeDeletions;
 	codeAdditions;
+	bufferBefore;
+	bufferAfter;
 	unsafeCSSStyle;
 	hoverContent;
 	headerElement;
 	headerMetadata;
 	separatorCache = /* @__PURE__ */ new Map();
 	errorWrapper;
+	placeHolder;
 	hunksRenderer;
 	resizeManager;
 	scrollSyncManager;
@@ -52,6 +55,7 @@ var FileDiff = class {
 	renderRange;
 	appliedPreAttributes;
 	lastRenderedHeaderHTML;
+	lastRowCount;
 	enabled = true;
 	constructor(options = { theme: DEFAULT_THEMES }, workerManager, isContainerManaged = false) {
 		this.options = options;
@@ -63,14 +67,67 @@ var FileDiff = class {
 		}, this.handleHighlightRender, this.workerManager);
 		this.resizeManager = new ResizeManager();
 		this.scrollSyncManager = new ScrollSyncManager();
-		this.mouseEventManager = new MouseEventManager("diff", pluckMouseEventOptions(options, typeof options.hunkSeparators === "function" || (options.hunkSeparators ?? "line-info") === "line-info" ? this.handleExpandHunk : void 0));
-		this.lineSelectionManager = new LineSelectionManager(pluckLineSelectionOptions(options));
+		this.mouseEventManager = new MouseEventManager("diff", pluckMouseEventOptions(options, typeof options.hunkSeparators === "function" || (options.hunkSeparators ?? "line-info") === "line-info" || options.hunkSeparators === "line-info-basic" ? this.handleExpandHunk : void 0));
+		this.lineSelectionManager = new LineSelectionManager(pluckLineSelectionOptions(options, this.getLineIndex));
 		this.workerManager?.subscribeToThemeChanges(this);
 		this.enabled = true;
 	}
 	handleHighlightRender = () => {
 		this.rerender();
 	};
+	getLineIndex = (lineNumber, side = "additions") => {
+		if (this.fileDiff == null) return;
+		const lastHunk = this.fileDiff.hunks.at(-1);
+		let targetUnifiedIndex;
+		let targetSplitIndex;
+		hunkIterator: for (const hunk of this.fileDiff.hunks) {
+			let currentLineNumber = side === "deletions" ? hunk.deletionStart : hunk.additionStart;
+			const hunkCount = side === "deletions" ? hunk.deletionCount : hunk.additionCount;
+			let splitIndex = hunk.splitLineStart;
+			let unifiedIndex = hunk.unifiedLineStart;
+			if (lineNumber < currentLineNumber) {
+				const difference = currentLineNumber - lineNumber;
+				targetUnifiedIndex = Math.max(unifiedIndex - difference, 0);
+				targetSplitIndex = Math.max(splitIndex - difference, 0);
+				break hunkIterator;
+			}
+			if (lineNumber >= currentLineNumber + hunkCount) {
+				if (hunk === lastHunk) {
+					const difference = lineNumber - (currentLineNumber + hunkCount);
+					targetUnifiedIndex = unifiedIndex + hunk.unifiedLineCount + difference;
+					targetSplitIndex = splitIndex + hunk.splitLineCount + difference;
+					break hunkIterator;
+				}
+				continue;
+			}
+			for (const content of hunk.hunkContent) if (content.type === "context") if (lineNumber < currentLineNumber + content.lines) {
+				const difference = lineNumber - currentLineNumber;
+				targetSplitIndex = splitIndex + difference;
+				targetUnifiedIndex = unifiedIndex + difference;
+				break hunkIterator;
+			} else {
+				currentLineNumber += content.lines;
+				splitIndex += content.lines;
+				unifiedIndex += content.lines;
+			}
+			else {
+				const sideCount = side === "deletions" ? content.deletions : content.additions;
+				if (lineNumber < currentLineNumber + sideCount) {
+					const indexDifference = lineNumber - currentLineNumber;
+					targetUnifiedIndex = unifiedIndex + (side === "additions" ? content.deletions : 0) + indexDifference;
+					targetSplitIndex = splitIndex + indexDifference;
+					break hunkIterator;
+				} else {
+					currentLineNumber += sideCount;
+					splitIndex += Math.max(content.deletions, content.additions);
+					unifiedIndex += content.deletions + content.additions;
+				}
+			}
+			break hunkIterator;
+		}
+		if (targetUnifiedIndex == null || targetSplitIndex == null) return;
+		return [targetUnifiedIndex, targetSplitIndex];
+	};
 	setOptions(options) {
 		if (options == null) return;
 		this.options = options;
@@ -78,8 +135,8 @@ var FileDiff = class {
 			...this.options,
 			hunkSeparators: typeof options.hunkSeparators === "function" ? "custom" : options.hunkSeparators
 		});
-		this.mouseEventManager.setOptions(pluckMouseEventOptions(options, typeof options.hunkSeparators === "function" || (options.hunkSeparators ?? "line-info") === "line-info" ? this.handleExpandHunk : void 0));
-		this.lineSelectionManager.setOptions(pluckLineSelectionOptions(options));
+		this.mouseEventManager.setOptions(pluckMouseEventOptions(options, typeof options.hunkSeparators === "function" || (options.hunkSeparators ?? "line-info") === "line-info" || options.hunkSeparators === "line-info-basic" ? this.handleExpandHunk : void 0));
+		this.lineSelectionManager.setOptions(pluckLineSelectionOptions(options, this.getLineIndex));
 	}
 	mergeOptions(options) {
 		this.options = {
@@ -109,6 +166,10 @@ var FileDiff = class {
 	setLineAnnotations(lineAnnotations) {
 		this.lineAnnotations = lineAnnotations;
 	}
+	canPartiallyRender(forceRender, annotationsChanged, didContentChange) {
+		if (forceRender || annotationsChanged || didContentChange || typeof this.options.hunkSeparators === "function") return false;
+		return true;
+	}
 	setSelectedLines(range) {
 		this.lineSelectionManager.setSelection(range);
 	}
@@ -129,11 +190,14 @@ var FileDiff = class {
 		this.codeUnified = void 0;
 		this.codeDeletions = void 0;
 		this.codeAdditions = void 0;
+		this.bufferBefore = void 0;
+		this.bufferAfter = void 0;
 		this.appliedPreAttributes = void 0;
 		this.headerElement = void 0;
 		this.lastRenderedHeaderHTML = void 0;
 		this.errorWrapper = void 0;
 		this.spriteSVG = void 0;
+		this.lastRowCount = void 0;
 		if (recycle) this.hunksRenderer.recycle();
 		else {
 			this.hunksRenderer.cleanUp();
@@ -149,6 +213,7 @@ var FileDiff = class {
 		this.workerManager?.subscribeToThemeChanges(this);
 	}
 	hydrate(props) {
+		const { overflow = "scroll", diffStyle = "split" } = this.options;
 		const { fileContainer, prerenderedHTML } = props;
 		prerenderHTMLIfNecessary(fileContainer, prerenderedHTML);
 		for (const element of fileContainer.shadowRoot?.children ?? []) {
@@ -192,10 +257,8 @@ var FileDiff = class {
 			this.injectUnsafeCSS();
 			this.mouseEventManager.setup(this.pre);
 			this.lineSelectionManager.setup(this.pre);
-			if ((this.options.overflow ?? "scroll") === "scroll") {
-				this.resizeManager.setup(this.pre);
-				if ((this.options.diffStyle ?? "split") === "split") this.scrollSyncManager.setup(this.pre, this.codeDeletions, this.codeAdditions);
-			}
+			this.resizeManager.setup(this.pre, overflow === "wrap");
+			if (overflow === "scroll" && diffStyle === "split") this.scrollSyncManager.setup(this.pre, this.codeDeletions, this.codeAdditions);
 		}
 	}
 	rerender() {
@@ -218,21 +281,26 @@ var FileDiff = class {
 	render({ oldFile, newFile, fileDiff, forceRender = false, lineAnnotations, fileContainer, containerWrapper, renderRange }) {
 		if (!this.enabled) throw new Error("FileDiff.render: attempting to call render after cleaned up");
 		const filesDidChange = oldFile != null && newFile != null && (!areFilesEqual(oldFile, this.deletionFile) || !areFilesEqual(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 (areRenderRangesEqual(renderRange, this.renderRange) && !forceRender && !annotationsChanged && (fileDiff != null && fileDiff === this.fileDiff || fileDiff == null && !filesDidChange)) return;
+		if (areRenderRangesEqual(renderRange, this.renderRange) && !forceRender && !annotationsChanged && (fileDiff != null && fileDiff === this.fileDiff || fileDiff == null && !filesDidChange)) return false;
+		const { renderRange: previousRenderRange } = this;
 		this.renderRange = renderRange;
 		this.deletionFile = oldFile;
 		this.additionFile = newFile;
 		if (fileDiff != null) this.fileDiff = fileDiff;
-		else if (oldFile != null && newFile != null && filesDidChange) this.fileDiff = parseDiffFromFile(oldFile, newFile);
+		else if (oldFile != null && newFile != null && filesDidChange) {
+			diffDidChange = true;
+			this.fileDiff = parseDiffFromFile(oldFile, newFile);
+		}
 		if (lineAnnotations != null) this.setLineAnnotations(lineAnnotations);
-		if (this.fileDiff == null) return;
+		if (this.fileDiff == null) return false;
 		this.hunksRenderer.setOptions({
 			...this.options,
 			hunkSeparators: typeof this.options.hunkSeparators === "function" ? "custom" : this.options.hunkSeparators
 		});
 		this.hunksRenderer.setLineAnnotations(this.lineAnnotations);
-		const { disableFileHeader = false } = this.options;
+		const { diffStyle = "split", disableErrorHandling = false, disableFileHeader = false, overflow = "scroll" } = this.options;
 		if (disableFileHeader) {
 			if (this.headerElement != null) {
 				this.headerElement.parentNode?.removeChild(this.headerElement);
@@ -242,28 +310,81 @@ var FileDiff = class {
 		}
 		fileContainer = this.getOrCreateFileContainer(fileContainer, containerWrapper);
 		try {
-			const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, renderRange);
-			if (hunksResult == null) {
-				if (this.workerManager != null && !this.workerManager.isInitialized()) this.workerManager.initialize().then(() => this.rerender());
-				return;
-			}
-			if (hunksResult.headerElement != null) this.applyHeaderToDOM(hunksResult.headerElement, fileContainer);
-			if (hunksResult.additionsAST != null || hunksResult.deletionsAST != null || hunksResult.unifiedAST != null) {
-				const pre = this.getOrCreatePreNode(fileContainer);
-				this.applyHunksToDOM(pre, hunksResult);
-			} else if (this.pre != null) {
-				this.pre.parentNode?.removeChild(this.pre);
-				this.pre = void 0;
+			const pre = this.getOrCreatePreNode(fileContainer);
+			if (!(this.canPartiallyRender(forceRender, annotationsChanged, filesDidChange || diffDidChange) && this.applyPartialRender({
+				previousRenderRange,
+				renderRange
+			}))) {
+				const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff, renderRange);
+				if (hunksResult == null) {
+					if (this.workerManager?.isInitialized() === false) this.workerManager.initialize().then(() => this.rerender());
+					return false;
+				}
+				if (hunksResult.headerElement != null) this.applyHeaderToDOM(hunksResult.headerElement, fileContainer);
+				if (hunksResult.additionsContentAST != null || hunksResult.deletionsContentAST != null || hunksResult.unifiedContentAST != null) this.applyHunksToDOM(pre, hunksResult);
+				else if (this.pre != null) {
+					this.pre.parentNode?.removeChild(this.pre);
+					this.pre = void 0;
+				}
+				this.renderSeparators(hunksResult.hunkData);
 			}
-			this.renderSeparators(hunksResult.hunkData);
+			this.applyBuffers(pre, renderRange);
+			this.injectUnsafeCSS();
 			this.renderAnnotations();
 			this.renderHoverUtility();
+			this.mouseEventManager.setup(pre);
+			this.lineSelectionManager.setup(pre);
+			this.resizeManager.setup(pre, overflow === "wrap");
+			if (overflow === "scroll" && diffStyle === "split") this.scrollSyncManager.setup(pre, this.codeDeletions, this.codeAdditions);
+			else this.scrollSyncManager.cleanUp();
 		} catch (error) {
-			if (error instanceof Error) {
-				console.error(error);
-				this.applyErrorToDOM(error, fileContainer);
-			}
+			if (disableErrorHandling) throw error;
+			console.error(error);
+			if (error instanceof Error) this.applyErrorToDOM(error, fileContainer);
+		}
+		return true;
+	}
+	renderPlaceholder(height) {
+		if (this.fileContainer == null) return false;
+		this.cleanChildNodes();
+		if (this.placeHolder == null) {
+			const shadowRoot = this.fileContainer.shadowRoot ?? this.fileContainer.attachShadow({ mode: "open" });
+			this.placeHolder = document.createElement("div");
+			this.placeHolder.dataset.placeholder = "";
+			shadowRoot.appendChild(this.placeHolder);
 		}
+		this.placeHolder.style.setProperty("height", `${height}px`);
+		return true;
+	}
+	cleanChildNodes() {
+		this.resizeManager.cleanUp();
+		this.scrollSyncManager.cleanUp();
+		this.mouseEventManager.cleanUp();
+		this.lineSelectionManager.cleanUp();
+		this.bufferAfter?.remove();
+		this.bufferBefore?.remove();
+		this.codeAdditions?.remove();
+		this.codeDeletions?.remove();
+		this.codeUnified?.remove();
+		this.errorWrapper?.remove();
+		this.headerElement?.remove();
+		this.hoverContent?.remove();
+		this.pre?.remove();
+		this.spriteSVG?.remove();
+		this.unsafeCSSStyle?.remove();
+		this.bufferAfter = void 0;
+		this.bufferBefore = void 0;
+		this.codeAdditions = void 0;
+		this.codeDeletions = void 0;
+		this.codeUnified = void 0;
+		this.errorWrapper = void 0;
+		this.headerElement = void 0;
+		this.hoverContent = void 0;
+		this.pre = void 0;
+		this.spriteSVG = void 0;
+		this.unsafeCSSStyle = void 0;
+		this.lastRenderedHeaderHTML = void 0;
+		this.lastRowCount = void 0;
 	}
 	renderSeparators(hunkData) {
 		const { hunkSeparators } = this.options;
@@ -375,6 +496,8 @@ var FileDiff = class {
 			shadowRoot.appendChild(this.pre);
 			this.appliedPreAttributes = void 0;
 		}
+		this.placeHolder?.remove();
+		this.placeHolder = void 0;
 		return this.pre;
 	}
 	syncCodeNodesFromPre(pre) {
@@ -390,6 +513,8 @@ var FileDiff = class {
 	}
 	applyHeaderToDOM(headerAST, container) {
 		this.cleanupErrorWrapper();
+		this.placeHolder?.remove();
+		this.placeHolder = void 0;
 		const headerHTML = toHtml(headerAST);
 		if (headerHTML !== this.lastRenderedHeaderHTML) {
 			const tempDiv = document.createElement("div");
@@ -428,72 +553,382 @@ var FileDiff = class {
 		this.unsafeCSSStyle.innerText = wrapUnsafeCSS(unsafeCSS);
 	}
 	applyHunksToDOM(pre, result) {
+		const { overflow = "scroll" } = this.options;
+		const rowSpan = overflow === "wrap" ? result.rowCount : void 0;
 		this.cleanupErrorWrapper();
 		this.applyPreNodeAttributes(pre, result);
 		let shouldReplace = false;
-		let codeDeletions;
-		let codeAdditions;
 		const codeElements = [];
-		if (result.unifiedAST != null) {
+		const unifiedAST = this.hunksRenderer.renderCodeAST("unified", result);
+		const deletionsAST = this.hunksRenderer.renderCodeAST("deletions", result);
+		const additionsAST = this.hunksRenderer.renderCodeAST("additions", result);
+		if (unifiedAST != null) {
 			shouldReplace = this.codeUnified == null || this.codeAdditions != null || this.codeDeletions != null;
+			this.codeDeletions?.remove();
 			this.codeDeletions = void 0;
+			this.codeAdditions?.remove();
 			this.codeAdditions = void 0;
-			if (result.unifiedAST.length > 0) {
-				this.codeUnified = getOrCreateCodeNode({
-					code: this.codeUnified,
-					columnType: "unified"
-				});
-				this.codeUnified.innerHTML = this.hunksRenderer.renderPartialHTML(result.unifiedAST);
-				codeElements.push(this.codeUnified);
-			} else this.codeUnified = void 0;
-		} else {
-			if (result.deletionsAST != null) {
+			this.codeUnified = getOrCreateCodeNode({
+				code: this.codeUnified,
+				columnType: "unified",
+				rowSpan
+			});
+			this.codeUnified.innerHTML = this.hunksRenderer.renderPartialHTML(unifiedAST);
+			codeElements.push(this.codeUnified);
+		} else if (deletionsAST != null || additionsAST != null) {
+			if (deletionsAST != null) {
 				shouldReplace = this.codeDeletions == null || this.codeUnified != null;
+				this.codeUnified?.remove();
 				this.codeUnified = void 0;
-				if (result.deletionsAST.length > 0) {
-					this.codeDeletions = getOrCreateCodeNode({
-						code: this.codeDeletions,
-						columnType: "deletions"
-					});
-					this.codeDeletions.innerHTML = this.hunksRenderer.renderPartialHTML(result.deletionsAST);
-					codeElements.push(this.codeDeletions);
-				} else this.codeDeletions = void 0;
+				this.codeDeletions = getOrCreateCodeNode({
+					code: this.codeDeletions,
+					columnType: "deletions",
+					rowSpan
+				});
+				this.codeDeletions.innerHTML = this.hunksRenderer.renderPartialHTML(deletionsAST);
+				codeElements.push(this.codeDeletions);
+			} else {
+				this.codeDeletions?.remove();
+				this.codeDeletions = void 0;
 			}
-			if (result.additionsAST != null) {
+			if (additionsAST != null) {
 				shouldReplace = shouldReplace || this.codeAdditions == null || this.codeUnified != null;
+				this.codeUnified?.remove();
 				this.codeUnified = void 0;
-				if (result.additionsAST.length > 0) {
-					this.codeAdditions = getOrCreateCodeNode({
-						code: this.codeAdditions,
-						columnType: "additions"
-					});
-					this.codeAdditions.innerHTML = this.hunksRenderer.renderPartialHTML(result.additionsAST);
-					codeElements.push(this.codeAdditions);
-				} else this.codeAdditions = void 0;
+				this.codeAdditions = getOrCreateCodeNode({
+					code: this.codeAdditions,
+					columnType: "additions",
+					rowSpan
+				});
+				this.codeAdditions.innerHTML = this.hunksRenderer.renderPartialHTML(additionsAST);
+				codeElements.push(this.codeAdditions);
+			} else {
+				this.codeAdditions?.remove();
+				this.codeAdditions = void 0;
 			}
+		} else {
+			this.codeUnified?.remove();
+			this.codeUnified = void 0;
+			this.codeDeletions?.remove();
+			this.codeDeletions = void 0;
+			this.codeAdditions?.remove();
+			this.codeAdditions = void 0;
 		}
 		if (codeElements.length === 0) pre.textContent = "";
 		else if (shouldReplace) pre.replaceChildren(...codeElements);
-		this.injectUnsafeCSS();
-		this.mouseEventManager.setup(pre);
-		this.lineSelectionManager.setup(pre);
-		if ((this.options.overflow ?? "scroll") === "scroll") {
-			this.resizeManager.setup(pre);
-			if ((this.options.diffStyle ?? "split") === "split") this.scrollSyncManager.setup(pre, codeDeletions, codeAdditions);
-			else this.scrollSyncManager.cleanUp();
+		this.lastRowCount = result.rowCount;
+	}
+	applyPartialRender({ previousRenderRange, renderRange }) {
+		const { pre, codeUnified, codeAdditions, codeDeletions, options: { diffStyle = "split" } } = this;
+		if (pre == null || previousRenderRange == null || renderRange == null || !Number.isFinite(previousRenderRange.totalLines) || !Number.isFinite(renderRange.totalLines) || this.lastRowCount == null) return false;
+		const codeElements = this.getCodeColumns(diffStyle, codeUnified, codeDeletions, codeAdditions);
+		if (codeElements == null) return false;
+		const previousStart = previousRenderRange.startingLine;
+		const nextStart = renderRange.startingLine;
+		const previousEnd = previousStart + previousRenderRange.totalLines;
+		const nextEnd = nextStart + renderRange.totalLines;
+		const overlapStart = Math.max(previousStart, nextStart);
+		const overlapEnd = Math.min(previousEnd, nextEnd);
+		if (overlapEnd <= overlapStart) return false;
+		const trimStart = Math.max(0, overlapStart - previousStart);
+		const trimEnd = Math.max(0, previousEnd - overlapEnd);
+		const trimResult = this.trimColumns({
+			columns: codeElements,
+			trimStart,
+			trimEnd,
+			previousStart,
+			overlapStart,
+			overlapEnd,
+			diffStyle
+		});
+		if (trimResult < 0) throw new Error("applyPartialRender: failed to trim to overlap");
+		if (this.lastRowCount < trimResult) throw new Error("applyPartialRender: trimmed beyond DOM row count");
+		let rowCount = this.lastRowCount - trimResult;
+		const renderChunk = (startingLine, totalLines) => {
+			if (totalLines <= 0 || this.fileDiff == null) return;
+			return this.hunksRenderer.renderDiff(this.fileDiff, {
+				startingLine,
+				totalLines,
+				bufferBefore: 0,
+				bufferAfter: 0
+			});
+		};
+		const prependResult = renderChunk(nextStart, Math.max(overlapStart - nextStart, 0));
+		if (prependResult == null && nextStart < overlapStart) return false;
+		const appendResult = renderChunk(overlapEnd, Math.max(nextEnd - overlapEnd, 0));
+		if (appendResult == null && nextEnd > overlapEnd) return false;
+		const applyChunk = (result, insertPosition) => {
+			if (result == null) return;
+			if (diffStyle === "unified" && !Array.isArray(codeElements)) this.insertPartialHTML(diffStyle, codeElements, result, insertPosition);
+			else if (diffStyle === "split" && Array.isArray(codeElements)) this.insertPartialHTML(diffStyle, codeElements, result, insertPosition);
+			else throw new Error("FileDiff.applyPartialRender.applyChunk: invalid chunk application");
+			rowCount += result.rowCount;
+		};
+		this.cleanupErrorWrapper();
+		applyChunk(prependResult, "afterbegin");
+		applyChunk(appendResult, "beforeend");
+		if (this.lastRowCount !== rowCount) {
+			this.applyRowSpan(diffStyle, codeElements, rowCount);
+			this.lastRowCount = rowCount;
+		}
+		return true;
+	}
+	insertPartialHTML(diffStyle, columns, result, insertPosition) {
+		if (diffStyle === "unified" && !Array.isArray(columns)) {
+			const unifiedAST = this.hunksRenderer.renderCodeAST("unified", result);
+			this.renderPartialColumn(columns, unifiedAST, insertPosition);
+		} else if (diffStyle === "split" && Array.isArray(columns)) {
+			const deletionsAST = this.hunksRenderer.renderCodeAST("deletions", result);
+			const additionsAST = this.hunksRenderer.renderCodeAST("additions", result);
+			this.renderPartialColumn(columns[0], deletionsAST, insertPosition);
+			this.renderPartialColumn(columns[1], additionsAST, insertPosition);
+		} else throw new Error("FileDiff.insertPartialHTML: Invalid argument composition");
+	}
+	renderPartialColumn(column, ast, insertPosition) {
+		if (column == null || ast == null) return;
+		const gutterChildren = getElementChildren(ast[0]);
+		const contentChildren = getElementChildren(ast[1]);
+		if (gutterChildren == null || contentChildren == null) throw new Error("FileDiff.insertPartialHTML: Unexpected AST structure");
+		const firstHASTElement = contentChildren.at(0);
+		if (insertPosition === "beforeend" && firstHASTElement?.type === "element" && typeof firstHASTElement.properties["data-buffer-size"] === "number") this.mergeBuffersIfNecessary(firstHASTElement.properties["data-buffer-size"], column.content.children[column.content.children.length - 1], column.gutter.children[column.gutter.children.length - 1], gutterChildren, contentChildren, true);
+		const lastHASTElement = contentChildren.at(-1);
+		if (insertPosition === "afterbegin" && lastHASTElement?.type === "element" && typeof lastHASTElement.properties["data-buffer-size"] === "number") this.mergeBuffersIfNecessary(lastHASTElement.properties["data-buffer-size"], column.content.children[0], column.gutter.children[0], gutterChildren, contentChildren, false);
+		column.gutter.insertAdjacentHTML(insertPosition, this.hunksRenderer.renderPartialHTML(gutterChildren));
+		column.content.insertAdjacentHTML(insertPosition, this.hunksRenderer.renderPartialHTML(contentChildren));
+	}
+	mergeBuffersIfNecessary(adjustmentSize, contentElement, gutterElement, gutterChildren, contentChildren, fromStart) {
+		if (!(contentElement instanceof HTMLElement) || !(gutterElement instanceof HTMLElement)) return;
+		const currentSize = this.getBufferSize(contentElement.dataset);
+		if (currentSize == null) return;
+		if (fromStart) {
+			gutterChildren.shift();
+			contentChildren.shift();
+		} else {
+			gutterChildren.pop();
+			contentChildren.pop();
+		}
+		this.updateBufferSize(contentElement, currentSize + adjustmentSize);
+		this.updateBufferSize(gutterElement, currentSize + adjustmentSize);
+	}
+	applyRowSpan(diffStyle, columns, rowCount) {
+		const applySpan = (column) => {
+			if (column == null) return;
+			column.gutter.style.setProperty("grid-row", `span ${rowCount}`);
+			column.content.style.setProperty("grid-row", `span ${rowCount}`);
+		};
+		if (diffStyle === "unified" && !Array.isArray(columns)) applySpan(columns);
+		else if (diffStyle === "split" && Array.isArray(columns)) {
+			applySpan(columns[0]);
+			applySpan(columns[1]);
+		} else throw new Error("dun fuuuuked up");
+	}
+	trimColumnRows(columns, preTrimCount, postTrimStart) {
+		let visibleLineIndex = 0;
+		let rowCount = 0;
+		let rowIndex = 0;
+		let pendingMetadataTrim = false;
+		const hasPostTrim = postTrimStart >= 0;
+		if (columns == null) return 0;
+		const contentChildren = Array.from(columns.content.children);
+		const gutterChildren = Array.from(columns.gutter.children);
+		if (contentChildren.length !== gutterChildren.length) throw new Error("FileDiff.trimColumnRows: columns do not match");
+		while (rowIndex < contentChildren.length) {
+			if (preTrimCount <= 0 && !hasPostTrim && !pendingMetadataTrim) break;
+			const gutterElement = gutterChildren[rowIndex];
+			const contentElement = contentChildren[rowIndex];
+			rowIndex++;
+			if (!(gutterElement instanceof HTMLElement) || !(contentElement instanceof HTMLElement)) {
+				console.error({
+					gutterElement,
+					contentElement
+				});
+				throw new Error("FileDiff.trimColumnRows: invalid row elements");
+			}
+			if (pendingMetadataTrim) {
+				pendingMetadataTrim = false;
+				if (gutterElement.dataset.gutterBuffer === "annotation" && "lineAnnotation" in contentElement.dataset || gutterElement.dataset.gutterBuffer === "metadata" && "noNewline" in contentElement.dataset) {
+					gutterElement.remove();
+					contentElement.remove();
+					rowCount++;
+					continue;
+				}
+			}
+			if ("lineIndex" in gutterElement.dataset && "lineIndex" in contentElement.dataset) {
+				if (preTrimCount > 0 || hasPostTrim && visibleLineIndex >= postTrimStart) {
+					gutterElement.remove();
+					contentElement.remove();
+					if (preTrimCount > 0) {
+						preTrimCount--;
+						if (preTrimCount === 0) pendingMetadataTrim = true;
+					}
+					rowCount++;
+				}
+				visibleLineIndex++;
+				continue;
+			}
+			if ("separator" in gutterElement.dataset && "separator" in contentElement.dataset) {
+				if (preTrimCount > 0 || hasPostTrim && visibleLineIndex >= postTrimStart) {
+					gutterElement.remove();
+					contentElement.remove();
+					rowCount++;
+				}
+				continue;
+			}
+			if (gutterElement.dataset.gutterBuffer === "annotation" && "lineAnnotation" in contentElement.dataset) {
+				if (preTrimCount > 0 || hasPostTrim && visibleLineIndex >= postTrimStart) {
+					gutterElement.remove();
+					contentElement.remove();
+					rowCount++;
+				}
+				continue;
+			}
+			if (gutterElement.dataset.gutterBuffer === "metadata" && "noNewline" in contentElement.dataset) {
+				if (preTrimCount > 0 || hasPostTrim && visibleLineIndex >= postTrimStart) {
+					gutterElement.remove();
+					contentElement.remove();
+					rowCount++;
+				}
+				continue;
+			}
+			if (gutterElement.dataset.gutterBuffer === "buffer" && "contentBuffer" in contentElement.dataset) {
+				const totalRows = this.getBufferSize(contentElement.dataset);
+				if (totalRows == null) throw new Error("FileDiff.trimColumnRows: invalid element");
+				if (preTrimCount > 0) {
+					const rowsToRemove = Math.min(preTrimCount, totalRows);
+					const newSize = totalRows - rowsToRemove;
+					if (newSize > 0) {
+						this.updateBufferSize(gutterElement, newSize);
+						this.updateBufferSize(contentElement, newSize);
+						rowCount += rowsToRemove;
+					} else {
+						gutterElement.remove();
+						contentElement.remove();
+						rowCount += totalRows;
+					}
+					preTrimCount -= rowsToRemove;
+				} else if (hasPostTrim) {
+					const bufferStart = visibleLineIndex;
+					const bufferEnd = visibleLineIndex + totalRows - 1;
+					if (postTrimStart <= bufferStart) {
+						gutterElement.remove();
+						contentElement.remove();
+						rowCount += totalRows;
+					} else if (postTrimStart <= bufferEnd) {
+						const rowsToRemove = bufferEnd - postTrimStart + 1;
+						const newSize = totalRows - rowsToRemove;
+						this.updateBufferSize(gutterElement, newSize);
+						this.updateBufferSize(contentElement, newSize);
+						rowCount += rowsToRemove;
+					}
+				}
+				visibleLineIndex += totalRows;
+				continue;
+			}
+			console.error({
+				gutterElement,
+				contentElement
+			});
+			throw new Error("FileDiff.trimColumnRows: unknown row elements");
+		}
+		return rowCount;
+	}
+	trimColumns({ columns, diffStyle, overlapEnd, overlapStart, previousStart, trimEnd, trimStart }) {
+		const preTrimCount = Math.max(0, overlapStart - previousStart);
+		const postTrimStart = overlapEnd - previousStart;
+		if (postTrimStart < 0) throw new Error("FileDiff.trimColumns: overlap ends before previous");
+		const shouldTrimStart = trimStart > 0;
+		const shouldTrimEnd = trimEnd > 0;
+		if (!shouldTrimStart && !shouldTrimEnd) return 0;
+		const effectivePreTrimCount = shouldTrimStart ? preTrimCount : 0;
+		const effectivePostTrimStart = shouldTrimEnd ? postTrimStart : -1;
+		if (diffStyle === "unified" && !Array.isArray(columns)) return this.trimColumnRows(columns, effectivePreTrimCount, effectivePostTrimStart);
+		else if (diffStyle === "split" && Array.isArray(columns)) {
+			const deletionsTrim = this.trimColumnRows(columns[0], effectivePreTrimCount, effectivePostTrimStart);
+			const additionsTrim = this.trimColumnRows(columns[1], effectivePreTrimCount, effectivePostTrimStart);
+			if (columns[0] != null && columns[1] != null && deletionsTrim !== additionsTrim) throw new Error("FileDiff.trimColumns: split columns out of sync");
+			return columns[0] != null ? deletionsTrim : additionsTrim;
 		} else {
-			this.resizeManager.cleanUp();
-			this.scrollSyncManager.cleanUp();
+			console.error({
+				diffStyle,
+				columns
+			});
+			throw new Error("FileDiff.trimColumns: Invalid columns for diffType");
+		}
+	}
+	getBufferSize(properties) {
+		const parsed = Number.parseInt(properties?.bufferSize ?? "", 10);
+		return Number.isNaN(parsed) ? void 0 : parsed;
+	}
+	updateBufferSize(element, size) {
+		element.dataset.bufferSize = `${size}`;
+		element.style.setProperty("grid-row", `span ${size}`);
+		element.style.setProperty("min-height", `calc(${size} * 1lh)`);
+	}
+	getCodeColumns(diffStyle, codeUnified, codeDeletions, codeAdditions) {
+		function getColumns(code) {
+			if (code == null) return;
+			const gutter = code.children[0];
+			const content = code.children[1];
+			if (!(gutter instanceof HTMLElement) || !(content instanceof HTMLElement) || gutter.dataset.gutter == null || content.dataset.content == null) return;
+			return {
+				gutter,
+				content
+			};
+		}
+		if (diffStyle === "unified") return getColumns(codeUnified);
+		else {
+			const deletions = getColumns(codeDeletions);
+			const additions = getColumns(codeAdditions);
+			return deletions != null || additions != null ? [deletions, additions] : void 0;
+		}
+	}
+	applyBuffers(pre, renderRange) {
+		const { disableVirtualizationBuffers = false } = this.options;
+		if (disableVirtualizationBuffers || renderRange == null) {
+			if (this.bufferBefore != null) {
+				this.bufferBefore.parentNode?.removeChild(this.bufferBefore);
+				this.bufferBefore = void 0;
+			}
+			if (this.bufferAfter != null) {
+				this.bufferAfter.parentNode?.removeChild(this.bufferAfter);
+				this.bufferAfter = void 0;
+			}
+			return;
+		}
+		if (renderRange.bufferBefore > 0) {
+			if (this.bufferBefore == null) {
+				this.bufferBefore = document.createElement("div");
+				this.bufferBefore.dataset.virtualizerBuffer = "before";
+				pre.before(this.bufferBefore);
+			}
+			this.bufferBefore.style.setProperty("height", `${renderRange.bufferBefore}px`);
+			this.bufferBefore.style.setProperty("contain", "strict");
+		} else if (this.bufferBefore != null) {
+			this.bufferBefore.parentNode?.removeChild(this.bufferBefore);
+			this.bufferBefore = void 0;
+		}
+		if (renderRange.bufferAfter > 0) {
+			if (this.bufferAfter == null) {
+				this.bufferAfter = document.createElement("div");
+				this.bufferAfter.dataset.virtualizerBuffer = "after";
+				pre.after(this.bufferAfter);
+			}
+			this.bufferAfter.style.setProperty("height", `${renderRange.bufferAfter}px`);
+			this.bufferAfter.style.setProperty("contain", "strict");
+		} else if (this.bufferAfter != null) {
+			this.bufferAfter.parentNode?.removeChild(this.bufferAfter);
+			this.bufferAfter = void 0;
 		}
 	}
-	applyPreNodeAttributes(pre, { themeStyles, baseThemeType, additionsAST, deletionsAST, totalLines }) {
+	applyPreNodeAttributes(pre, { themeStyles, baseThemeType, additionsContentAST, deletionsContentAST, totalLines }) {
 		const { diffIndicators = "bars", disableBackground = false, disableLineNumbers = false, overflow = "scroll", themeType = "system", diffStyle = "split" } = this.options;
 		const preProperties = {
+			type: "diff",
 			diffIndicators,
 			disableBackground,
 			disableLineNumbers,
 			overflow,
-			split: diffStyle === "unified" ? false : additionsAST != null && deletionsAST != null,
+			split: diffStyle === "unified" ? false : additionsContentAST != null && deletionsContentAST != null,
 			themeStyles,
 			themeType: baseThemeType ?? themeType,
 			totalLines
@@ -528,6 +963,10 @@ var FileDiff = class {
 		this.errorWrapper = void 0;
 	}
 };
+function getElementChildren(node) {
+	if (node == null || node.type !== "element") return;
+	return node.children ?? [];
+}
 
 //#endregion
 export { FileDiff };