@pierre/diffs 1.1.0-beta.6 → 1.1.0-beta.8

package/dist/components/VirtualizedFile.js

@@ -0,0 +1,227 @@
+import { DEFAULT_VIRTUAL_FILE_METRICS } from "../constants.js";
+import { iterateOverFile } from "../utils/iterateOverFile.js";
+import { File } from "./File.js";
+
+//#region src/components/VirtualizedFile.ts
+let instanceId = -1;
+var VirtualizedFile = class extends File {
+	__id = `virtualized-file:${++instanceId}`;
+	top;
+	height = 0;
+	heightCache = /* @__PURE__ */ new Map();
+	isVisible = false;
+	constructor(options, virtualizer, metrics = DEFAULT_VIRTUAL_FILE_METRICS, workerManager, isContainerManaged = false) {
+		super(options, workerManager, isContainerManaged);
+		this.virtualizer = virtualizer;
+		this.metrics = metrics;
+	}
+	getLineHeight(lineIndex, hasMetadataLine = false) {
+		const cached = this.heightCache.get(lineIndex);
+		if (cached != null) return cached;
+		const multiplier = hasMetadataLine ? 2 : 1;
+		return this.metrics.lineHeight * multiplier;
+	}
+	setOptions(options) {
+		if (options == null) return;
+		const previousOverflow = this.options.overflow;
+		super.setOptions(options);
+		if (previousOverflow !== this.options.overflow) {
+			this.heightCache.clear();
+			this.computeApproximateSize();
+			this.renderRange = void 0;
+		}
+		this.virtualizer.instanceChanged(this);
+	}
+	reconcileHeights() {
+		if (this.fileContainer == null || this.file == null) {
+			this.height = 0;
+			return;
+		}
+		const { overflow = "scroll" } = this.options;
+		this.top = this.virtualizer.getOffsetInScrollContainer(this.fileContainer);
+		if (overflow === "scroll" && this.lineAnnotations.length === 0 && !this.virtualizer.config.resizeDebugging) return;
+		let hasLineHeightChange = false;
+		if (this.code == null) return;
+		const content = this.code.children[1];
+		if (!(content instanceof HTMLElement)) return;
+		for (const line of content.children) {
+			if (!(line instanceof HTMLElement)) continue;
+			const lineIndexAttr = line.dataset.lineIndex;
+			if (lineIndexAttr == null) continue;
+			const lineIndex = Number(lineIndexAttr);
+			let measuredHeight = line.getBoundingClientRect().height;
+			let hasMetadata = false;
+			if (line.nextElementSibling instanceof HTMLElement && ("lineAnnotation" in line.nextElementSibling.dataset || "noNewline" in line.nextElementSibling.dataset)) {
+				if ("noNewline" in line.nextElementSibling.dataset) hasMetadata = true;
+				measuredHeight += line.nextElementSibling.getBoundingClientRect().height;
+			}
+			const expectedHeight = this.getLineHeight(lineIndex, hasMetadata);
+			if (measuredHeight === expectedHeight) continue;
+			hasLineHeightChange = true;
+			if (measuredHeight === this.metrics.lineHeight * (hasMetadata ? 2 : 1)) this.heightCache.delete(lineIndex);
+			else this.heightCache.set(lineIndex, measuredHeight);
+		}
+		if (hasLineHeightChange || this.virtualizer.config.resizeDebugging) this.computeApproximateSize();
+	}
+	onRender = (dirty) => {
+		if (this.fileContainer == null || this.file == null) return false;
+		if (dirty) this.top = this.virtualizer.getOffsetInScrollContainer(this.fileContainer);
+		return this.render({ file: this.file });
+	};
+	cleanUp() {
+		if (this.fileContainer != null) this.virtualizer.disconnect(this.fileContainer);
+		super.cleanUp();
+	}
+	computeApproximateSize() {
+		this.height = 0;
+		if (this.file == null) return;
+		const { disableFileHeader = false, overflow = "scroll" } = this.options;
+		const { diffHeaderHeight, fileGap, lineHeight } = this.metrics;
+		const lines = this.getOrCreateLineCache(this.file);
+		if (!disableFileHeader) this.height += diffHeaderHeight;
+		else this.height += fileGap;
+		if (overflow === "scroll" && this.lineAnnotations.length === 0) this.height += this.getOrCreateLineCache(this.file).length * lineHeight;
+		else iterateOverFile({
+			lines,
+			callback: ({ lineIndex }) => {
+				this.height += this.getLineHeight(lineIndex, false);
+			}
+		});
+		if (lines.length > 0) this.height += fileGap;
+		if (this.fileContainer != null && this.virtualizer.config.resizeDebugging) {
+			const rect = this.fileContainer.getBoundingClientRect();
+			if (rect.height !== this.height) console.log("VirtualizedFile.computeApproximateSize: computed height doesnt match", {
+				name: this.file.name,
+				elementHeight: rect.height,
+				computedHeight: this.height
+			});
+			else console.log("VirtualizedFile.computeApproximateSize: computed height IS CORRECT");
+		}
+	}
+	setVisibility(visible) {
+		if (this.fileContainer == null) return;
+		if (visible && !this.isVisible) {
+			this.top = this.virtualizer.getOffsetInScrollContainer(this.fileContainer);
+			this.isVisible = true;
+		} else if (!visible && this.isVisible) {
+			this.isVisible = false;
+			this.rerender();
+		}
+	}
+	render({ fileContainer, file,...props }) {
+		const isFirstRender = this.fileContainer == null;
+		this.file ??= file;
+		fileContainer = this.getOrCreateFileContainerNode(fileContainer);
+		if (this.file == null) {
+			console.error("VirtualizedFile.render: attempting to virtually render when we dont have file");
+			return false;
+		}
+		this.top ??= this.virtualizer.getOffsetInScrollContainer(fileContainer);
+		if (isFirstRender) {
+			this.computeApproximateSize();
+			this.virtualizer.connect(fileContainer, this);
+			this.isVisible = this.virtualizer.isInstanceVisible(this.top, this.height);
+		}
+		if (!this.isVisible) return this.renderPlaceholder(this.height);
+		const windowSpecs = this.virtualizer.getWindowSpecs();
+		const renderRange = this.computeRenderRangeFromWindow(this.file, this.top, windowSpecs);
+		return super.render({
+			file: this.file,
+			fileContainer,
+			renderRange,
+			...props
+		});
+	}
+	computeRenderRangeFromWindow(file, fileTop, { top, bottom }) {
+		const { disableFileHeader = false, overflow = "scroll" } = this.options;
+		const { diffHeaderHeight, fileGap, hunkLineCount, lineHeight } = this.metrics;
+		const lines = this.getOrCreateLineCache(file);
+		const lineCount = lines.length;
+		const fileHeight = this.height;
+		const headerRegion = disableFileHeader ? fileGap : diffHeaderHeight;
+		if (fileTop < top - fileHeight || fileTop > bottom) return {
+			startingLine: 0,
+			totalLines: 0,
+			bufferBefore: 0,
+			bufferAfter: fileHeight - headerRegion - fileGap
+		};
+		if (lineCount <= hunkLineCount) return {
+			startingLine: 0,
+			totalLines: hunkLineCount,
+			bufferBefore: 0,
+			bufferAfter: 0
+		};
+		const estimatedTargetLines = Math.ceil(Math.max(bottom - top, 0) / lineHeight);
+		const totalLines = Math.ceil(estimatedTargetLines / hunkLineCount) * hunkLineCount + hunkLineCount * 2;
+		const totalHunks = totalLines / hunkLineCount;
+		const viewportCenter = (top + bottom) / 2;
+		if (overflow === "scroll" && this.lineAnnotations.length === 0) {
+			const centerLine = Math.floor((viewportCenter - (fileTop + headerRegion)) / lineHeight);
+			const idealStartHunk$1 = Math.floor(centerLine / hunkLineCount) - Math.floor(totalHunks / 2);
+			const totalHunksInFile = Math.ceil(lineCount / hunkLineCount);
+			const startingLine$1 = Math.max(0, Math.min(idealStartHunk$1, totalHunksInFile)) * hunkLineCount;
+			const clampedTotalLines$1 = idealStartHunk$1 < 0 ? totalLines + idealStartHunk$1 * hunkLineCount : totalLines;
+			const bufferBefore$1 = startingLine$1 * lineHeight;
+			const renderedLines = Math.min(clampedTotalLines$1, lineCount - startingLine$1);
+			return {
+				startingLine: startingLine$1,
+				totalLines: clampedTotalLines$1,
+				bufferBefore: bufferBefore$1,
+				bufferAfter: Math.max(0, (lineCount - startingLine$1 - renderedLines) * lineHeight)
+			};
+		}
+		const overflowHunks = totalHunks;
+		const hunkOffsets = [];
+		let absoluteLineTop = fileTop + headerRegion;
+		let currentLine = 0;
+		let firstVisibleHunk;
+		let centerHunk;
+		let overflowCounter;
+		iterateOverFile({
+			lines,
+			callback: ({ lineIndex }) => {
+				const isAtHunkBoundary = currentLine % hunkLineCount === 0;
+				if (isAtHunkBoundary) {
+					hunkOffsets.push(absoluteLineTop - (fileTop + headerRegion));
+					if (overflowCounter != null) {
+						if (overflowCounter <= 0) return true;
+						overflowCounter--;
+					}
+				}
+				const lineHeight$1 = this.getLineHeight(lineIndex, false);
+				const currentHunk = Math.floor(currentLine / hunkLineCount);
+				if (absoluteLineTop > top - lineHeight$1 && absoluteLineTop < bottom) firstVisibleHunk ??= currentHunk;
+				if (absoluteLineTop + lineHeight$1 > viewportCenter) centerHunk ??= currentHunk;
+				if (overflowCounter == null && absoluteLineTop >= bottom && isAtHunkBoundary) overflowCounter = overflowHunks;
+				currentLine++;
+				absoluteLineTop += lineHeight$1;
+				return false;
+			}
+		});
+		if (firstVisibleHunk == null) return {
+			startingLine: 0,
+			totalLines: 0,
+			bufferBefore: 0,
+			bufferAfter: fileHeight - headerRegion - fileGap
+		};
+		const collectedHunks = hunkOffsets.length;
+		centerHunk ??= firstVisibleHunk;
+		const idealStartHunk = Math.round(centerHunk - totalHunks / 2);
+		const maxStartHunk = Math.max(0, collectedHunks - totalHunks);
+		const startHunk = Math.max(0, Math.min(idealStartHunk, maxStartHunk));
+		const startingLine = startHunk * hunkLineCount;
+		const clampedTotalLines = idealStartHunk < 0 ? totalLines + idealStartHunk * hunkLineCount : totalLines;
+		const bufferBefore = hunkOffsets[startHunk] ?? 0;
+		const finalHunkIndex = startHunk + clampedTotalLines / hunkLineCount;
+		return {
+			startingLine,
+			totalLines: clampedTotalLines,
+			bufferBefore,
+			bufferAfter: finalHunkIndex < hunkOffsets.length ? fileHeight - headerRegion - hunkOffsets[finalHunkIndex] - fileGap : fileHeight - (absoluteLineTop - fileTop) - fileGap
+		};
+	}
+};
+
+//#endregion
+export { VirtualizedFile };
+//# sourceMappingURL=VirtualizedFile.js.map

package/dist/components/VirtualizedFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualizedFile.js","names":["virtualizer: Virtualizer","metrics: VirtualFileMetrics","idealStartHunk","startingLine","clampedTotalLines","bufferBefore","hunkOffsets: number[]","firstVisibleHunk: number | undefined","centerHunk: number | undefined","overflowCounter: number | undefined","lineHeight"],"sources":["../../src/components/VirtualizedFile.ts"],"sourcesContent":["import { DEFAULT_VIRTUAL_FILE_METRICS } from '../constants';\nimport type {\n  FileContents,\n  RenderRange,\n  RenderWindow,\n  VirtualFileMetrics,\n} from '../types';\nimport { iterateOverFile } from '../utils/iterateOverFile';\nimport type { WorkerPoolManager } from '../worker';\nimport { File, type FileOptions, type FileRenderProps } from './File';\nimport type { Virtualizer } from './Virtualizer';\n\nlet instanceId = -1;\n\nexport class VirtualizedFile<\n  LAnnotation = undefined,\n> extends File<LAnnotation> {\n  override readonly __id: string = `virtualized-file:${++instanceId}`;\n\n  public top: number | undefined;\n  public height: number = 0;\n  // Sparse map: line index -> measured height\n  // Only stores lines that differ from what is returned from default line\n  // height\n  private heightCache: Map<number, number> = new Map();\n  private isVisible: boolean = false;\n\n  constructor(\n    options: FileOptions<LAnnotation> | undefined,\n    private virtualizer: Virtualizer,\n    private metrics: VirtualFileMetrics = DEFAULT_VIRTUAL_FILE_METRICS,\n    workerManager?: WorkerPoolManager,\n    isContainerManaged = false\n  ) {\n    super(options, workerManager, isContainerManaged);\n  }\n\n  // Get the height for a line, using cached value if available.\n  // If not cached and hasMetadataLine is true, adds lineHeight for the\n  // metadata.\n  public getLineHeight(lineIndex: number, hasMetadataLine = false): number {\n    const cached = this.heightCache.get(lineIndex);\n    if (cached != null) {\n      return cached;\n    }\n    const multiplier = hasMetadataLine ? 2 : 1;\n    return this.metrics.lineHeight * multiplier;\n  }\n\n  // Override setOptions to clear height cache when overflow changes\n  override setOptions(options: FileOptions<LAnnotation> | undefined): void {\n    if (options == null) return;\n    const previousOverflow = this.options.overflow;\n\n    super.setOptions(options);\n\n    if (previousOverflow !== this.options.overflow) {\n      this.heightCache.clear();\n      this.computeApproximateSize();\n      this.renderRange = undefined;\n    }\n    this.virtualizer.instanceChanged(this);\n  }\n\n  // Measure rendered lines and update height cache.\n  // Called after render to reconcile estimated vs actual heights.\n  public reconcileHeights(): void {\n    if (this.fileContainer == null || this.file == null) {\n      this.height = 0;\n      return;\n    }\n    const { overflow = 'scroll' } = this.options;\n    this.top = this.virtualizer.getOffsetInScrollContainer(this.fileContainer);\n\n    // If the file has no annotations and we are using the scroll variant, then\n    // we can probably skip everything\n    if (\n      overflow === 'scroll' &&\n      this.lineAnnotations.length === 0 &&\n      !this.virtualizer.config.resizeDebugging\n    ) {\n      return;\n    }\n\n    let hasLineHeightChange = false;\n\n    // Single code element (no split mode)\n    if (this.code == null) return;\n    const content = this.code.children[1]; // Content column (gutter is [0])\n    if (!(content instanceof HTMLElement)) return;\n\n    for (const line of content.children) {\n      if (!(line instanceof HTMLElement)) continue;\n\n      const lineIndexAttr = line.dataset.lineIndex;\n      if (lineIndexAttr == null) continue;\n\n      const lineIndex = Number(lineIndexAttr);\n      let measuredHeight = line.getBoundingClientRect().height;\n      let hasMetadata = false;\n\n      // Annotations or noNewline metadata increase the size of their attached line\n      if (\n        line.nextElementSibling instanceof HTMLElement &&\n        ('lineAnnotation' in line.nextElementSibling.dataset ||\n          'noNewline' in line.nextElementSibling.dataset)\n      ) {\n        if ('noNewline' in line.nextElementSibling.dataset) {\n          hasMetadata = true;\n        }\n        measuredHeight +=\n          line.nextElementSibling.getBoundingClientRect().height;\n      }\n\n      const expectedHeight = this.getLineHeight(lineIndex, hasMetadata);\n\n      if (measuredHeight === expectedHeight) {\n        continue;\n      }\n\n      hasLineHeightChange = true;\n      // Line is back to standard height (e.g., after window resize)\n      // Remove from cache\n      if (measuredHeight === this.metrics.lineHeight * (hasMetadata ? 2 : 1)) {\n        this.heightCache.delete(lineIndex);\n      }\n      // Non-standard height, cache it\n      else {\n        this.heightCache.set(lineIndex, measuredHeight);\n      }\n    }\n\n    if (hasLineHeightChange || this.virtualizer.config.resizeDebugging) {\n      this.computeApproximateSize();\n    }\n  }\n\n  public onRender = (dirty: boolean): boolean => {\n    if (this.fileContainer == null || this.file == null) {\n      return false;\n    }\n    if (dirty) {\n      this.top = this.virtualizer.getOffsetInScrollContainer(\n        this.fileContainer\n      );\n    }\n    return this.render({ file: this.file });\n  };\n\n  override cleanUp(): void {\n    if (this.fileContainer != null) {\n      this.virtualizer.disconnect(this.fileContainer);\n    }\n    super.cleanUp();\n  }\n\n  // Compute the approximate size of the file using cached line heights.\n  // Uses lineHeight for lines without cached measurements.\n  private computeApproximateSize(): void {\n    this.height = 0;\n    if (this.file == null) {\n      return;\n    }\n\n    const { disableFileHeader = false, overflow = 'scroll' } = this.options;\n    const { diffHeaderHeight, fileGap, lineHeight } = this.metrics;\n    const lines = this.getOrCreateLineCache(this.file);\n\n    // Header or initial padding\n    if (!disableFileHeader) {\n      this.height += diffHeaderHeight;\n    } else {\n      this.height += fileGap;\n    }\n\n    if (overflow === 'scroll' && this.lineAnnotations.length === 0) {\n      this.height += this.getOrCreateLineCache(this.file).length * lineHeight;\n    } else {\n      iterateOverFile({\n        lines,\n        callback: ({ lineIndex }) => {\n          this.height += this.getLineHeight(lineIndex, false);\n        },\n      });\n    }\n\n    // Bottom padding\n    if (lines.length > 0) {\n      this.height += fileGap;\n    }\n\n    if (this.fileContainer != null && this.virtualizer.config.resizeDebugging) {\n      const rect = this.fileContainer.getBoundingClientRect();\n      if (rect.height !== this.height) {\n        console.log(\n          'VirtualizedFile.computeApproximateSize: computed height doesnt match',\n          {\n            name: this.file.name,\n            elementHeight: rect.height,\n            computedHeight: this.height,\n          }\n        );\n      } else {\n        console.log(\n          'VirtualizedFile.computeApproximateSize: computed height IS CORRECT'\n        );\n      }\n    }\n  }\n\n  public setVisibility(visible: boolean): void {\n    if (this.fileContainer == null) {\n      return;\n    }\n    if (visible && !this.isVisible) {\n      this.top = this.virtualizer.getOffsetInScrollContainer(\n        this.fileContainer\n      );\n      this.isVisible = true;\n    } else if (!visible && this.isVisible) {\n      this.isVisible = false;\n      this.rerender();\n    }\n  }\n\n  override render({\n    fileContainer,\n    file,\n    ...props\n  }: FileRenderProps<LAnnotation>): boolean {\n    const isFirstRender = this.fileContainer == null;\n\n    this.file ??= file;\n\n    fileContainer = this.getOrCreateFileContainerNode(fileContainer);\n\n    if (this.file == null) {\n      console.error(\n        'VirtualizedFile.render: attempting to virtually render when we dont have file'\n      );\n      return false;\n    }\n\n    this.top ??= this.virtualizer.getOffsetInScrollContainer(fileContainer);\n    if (isFirstRender) {\n      this.computeApproximateSize();\n      this.virtualizer.connect(fileContainer, this);\n      this.isVisible = this.virtualizer.isInstanceVisible(\n        this.top,\n        this.height\n      );\n    }\n\n    if (!this.isVisible) {\n      return this.renderPlaceholder(this.height);\n    }\n\n    const windowSpecs = this.virtualizer.getWindowSpecs();\n    const renderRange = this.computeRenderRangeFromWindow(\n      this.file,\n      this.top,\n      windowSpecs\n    );\n    return super.render({\n      file: this.file,\n      fileContainer,\n      renderRange,\n      ...props,\n    });\n  }\n\n  private computeRenderRangeFromWindow(\n    file: FileContents,\n    fileTop: number,\n    { top, bottom }: RenderWindow\n  ): RenderRange {\n    const { disableFileHeader = false, overflow = 'scroll' } = this.options;\n    const { diffHeaderHeight, fileGap, hunkLineCount, lineHeight } =\n      this.metrics;\n    const lines = this.getOrCreateLineCache(file);\n    const lineCount = lines.length;\n    const fileHeight = this.height;\n    const headerRegion = disableFileHeader ? fileGap : diffHeaderHeight;\n\n    // File is outside render window\n    if (fileTop < top - fileHeight || fileTop > bottom) {\n      return {\n        startingLine: 0,\n        totalLines: 0,\n        bufferBefore: 0,\n        bufferAfter: fileHeight - headerRegion - fileGap,\n      };\n    }\n\n    // Small file, just render it all\n    if (lineCount <= hunkLineCount) {\n      return {\n        startingLine: 0,\n        totalLines: hunkLineCount,\n        bufferBefore: 0,\n        bufferAfter: 0,\n      };\n    }\n\n    // Calculate totalLines based on viewport size\n    const estimatedTargetLines = Math.ceil(\n      Math.max(bottom - top, 0) / lineHeight\n    );\n    const totalLines =\n      Math.ceil(estimatedTargetLines / hunkLineCount) * hunkLineCount +\n      hunkLineCount * 2;\n    const totalHunks = totalLines / hunkLineCount;\n    const viewportCenter = (top + bottom) / 2;\n\n    // Simple case: overflow scroll with no annotations - pure math!\n    if (overflow === 'scroll' && this.lineAnnotations.length === 0) {\n      // Find which line is at viewport center\n      const centerLine = Math.floor(\n        (viewportCenter - (fileTop + headerRegion)) / lineHeight\n      );\n      const centerHunk = Math.floor(centerLine / hunkLineCount);\n\n      // Calculate ideal start centered around viewport\n      const idealStartHunk = centerHunk - Math.floor(totalHunks / 2);\n      const totalHunksInFile = Math.ceil(lineCount / hunkLineCount);\n      const startingLine =\n        Math.max(0, Math.min(idealStartHunk, totalHunksInFile)) * hunkLineCount;\n\n      const clampedTotalLines =\n        idealStartHunk < 0\n          ? totalLines + idealStartHunk * hunkLineCount\n          : totalLines;\n\n      const bufferBefore = startingLine * lineHeight;\n      const renderedLines = Math.min(\n        clampedTotalLines,\n        lineCount - startingLine\n      );\n      const bufferAfter = Math.max(\n        0,\n        (lineCount - startingLine - renderedLines) * lineHeight\n      );\n\n      return {\n        startingLine,\n        totalLines: clampedTotalLines,\n        bufferBefore,\n        bufferAfter,\n      };\n    }\n\n    // Complex case: need to account for line annotations or wrap overflow\n    const overflowHunks = totalHunks;\n    const hunkOffsets: number[] = [];\n\n    let absoluteLineTop = fileTop + headerRegion;\n    let currentLine = 0;\n    let firstVisibleHunk: number | undefined;\n    let centerHunk: number | undefined;\n    let overflowCounter: number | undefined;\n\n    iterateOverFile({\n      lines,\n      callback: ({ lineIndex }) => {\n        const isAtHunkBoundary = currentLine % hunkLineCount === 0;\n\n        if (isAtHunkBoundary) {\n          hunkOffsets.push(absoluteLineTop - (fileTop + headerRegion));\n\n          if (overflowCounter != null) {\n            if (overflowCounter <= 0) {\n              return true;\n            }\n            overflowCounter--;\n          }\n        }\n\n        const lineHeight = this.getLineHeight(lineIndex, false);\n        const currentHunk = Math.floor(currentLine / hunkLineCount);\n\n        // Track visible region\n        if (absoluteLineTop > top - lineHeight && absoluteLineTop < bottom) {\n          firstVisibleHunk ??= currentHunk;\n        }\n\n        // Track which hunk contains the viewport center\n        if (absoluteLineTop + lineHeight > viewportCenter) {\n          centerHunk ??= currentHunk;\n        }\n\n        // Start overflow when we are out of the viewport at a hunk boundary\n        if (\n          overflowCounter == null &&\n          absoluteLineTop >= bottom &&\n          isAtHunkBoundary\n        ) {\n          overflowCounter = overflowHunks;\n        }\n\n        currentLine++;\n        absoluteLineTop += lineHeight;\n\n        return false;\n      },\n    });\n\n    // No visible lines found\n    if (firstVisibleHunk == null) {\n      return {\n        startingLine: 0,\n        totalLines: 0,\n        bufferBefore: 0,\n        bufferAfter: fileHeight - headerRegion - fileGap,\n      };\n    }\n\n    // Calculate balanced startingLine centered around the viewport center\n    const collectedHunks = hunkOffsets.length;\n    centerHunk ??= firstVisibleHunk;\n    const idealStartHunk = Math.round(centerHunk - totalHunks / 2);\n\n    // Clamp startHunk: at the beginning, reduce totalLines; at the end, shift startHunk back\n    const maxStartHunk = Math.max(0, collectedHunks - totalHunks);\n    const startHunk = Math.max(0, Math.min(idealStartHunk, maxStartHunk));\n    const startingLine = startHunk * hunkLineCount;\n\n    // If we wanted to start before 0, reduce totalLines by the clamped amount\n    const clampedTotalLines =\n      idealStartHunk < 0\n        ? totalLines + idealStartHunk * hunkLineCount\n        : totalLines;\n\n    // Use hunkOffsets array for efficient buffer calculations\n    const bufferBefore = hunkOffsets[startHunk] ?? 0;\n\n    // Calculate bufferAfter\n    const finalHunkIndex = startHunk + clampedTotalLines / hunkLineCount;\n    const bufferAfter =\n      finalHunkIndex < hunkOffsets.length\n        ? fileHeight - headerRegion - hunkOffsets[finalHunkIndex] - fileGap\n        : fileHeight - (absoluteLineTop - fileTop) - fileGap;\n\n    return {\n      startingLine,\n      totalLines: clampedTotalLines,\n      bufferBefore,\n      bufferAfter,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/components/VirtualizedFileDiff.d.ts

@@ -0,0 +1,39 @@
+import { ExpansionDirections, VirtualFileMetrics } from "../types.js";
+import { WorkerPoolManager } from "../worker/WorkerPoolManager.js";
+import "../worker/index.js";
+import { Virtualizer } from "./Virtualizer.js";
+import { FileDiff, FileDiffOptions, FileDiffRenderProps } from "./FileDiff.js";
+
+//#region src/components/VirtualizedFileDiff.d.ts
+declare class VirtualizedFileDiff<LAnnotation = undefined> extends FileDiff<LAnnotation> {
+  readonly __id: string;
+  top: number | undefined;
+  height: number;
+  private metrics;
+  private heightCache;
+  private isVisible;
+  private virtualizer;
+  constructor(options: FileDiffOptions<LAnnotation> | undefined, virtualizer: Virtualizer, metrics?: Partial<VirtualFileMetrics>, workerManager?: WorkerPoolManager, isContainerManaged?: boolean);
+  private getLineHeight;
+  setOptions(options: FileDiffOptions<LAnnotation> | undefined): void;
+  reconcileHeights(): void;
+  onRender: (dirty: boolean) => boolean;
+  cleanUp(): void;
+  expandHunk(hunkIndex: number, direction: ExpansionDirections): void;
+  setVisibility(visible: boolean): void;
+  private computeApproximateSize;
+  render({
+    fileContainer,
+    oldFile,
+    newFile,
+    fileDiff,
+    ...props
+  }?: FileDiffRenderProps<LAnnotation>): boolean;
+  private getDiffStyle;
+  private getExpandedRegion;
+  private getExpandedLineCount;
+  private computeRenderRangeFromWindow;
+}
+//#endregion
+export { VirtualizedFileDiff };
+//# sourceMappingURL=VirtualizedFileDiff.d.ts.map

package/dist/components/VirtualizedFileDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualizedFileDiff.d.ts","names":["ExpansionDirections","VirtualFileMetrics","WorkerPoolManager","FileDiff","FileDiffOptions","FileDiffRenderProps","Virtualizer","VirtualizedFileDiff","LAnnotation","Partial","fileContainer","oldFile","newFile","fileDiff"],"sources":["../../src/components/VirtualizedFileDiff.d.ts"],"sourcesContent":["import type { ExpansionDirections, VirtualFileMetrics } from '../types';\nimport type { WorkerPoolManager } from '../worker';\nimport { FileDiff, type FileDiffOptions, type FileDiffRenderProps } from './FileDiff';\nimport type { Virtualizer } from './Virtualizer';\nexport declare class VirtualizedFileDiff<LAnnotation = undefined> extends FileDiff<LAnnotation> {\n    readonly __id: string;\n    top: number | undefined;\n    height: number;\n    private metrics;\n    private heightCache;\n    private isVisible;\n    private virtualizer;\n    constructor(options: FileDiffOptions<LAnnotation> | undefined, virtualizer: Virtualizer, metrics?: Partial<VirtualFileMetrics>, workerManager?: WorkerPoolManager, isContainerManaged?: boolean);\n    private getLineHeight;\n    setOptions(options: FileDiffOptions<LAnnotation> | undefined): void;\n    reconcileHeights(): void;\n    onRender: (dirty: boolean) => boolean;\n    cleanUp(): void;\n    expandHunk(hunkIndex: number, direction: ExpansionDirections): void;\n    setVisibility(visible: boolean): void;\n    private computeApproximateSize;\n    render({ fileContainer, oldFile, newFile, fileDiff, ...props }?: FileDiffRenderProps<LAnnotation>): boolean;\n    private getDiffStyle;\n    private getExpandedRegion;\n    private getExpandedLineCount;\n    private computeRenderRangeFromWindow;\n}\n//# sourceMappingURL=VirtualizedFileDiff.d.ts.map"],"mappings":";;;;;;;cAIqBO,qDAAqDJ,SAASK;;;EAA9DD,MAAAA,EAAAA,MAAAA;EAA8DC,QAAAA,OAAAA;EAQ1CA,QAAAA,WAAAA;EAAhBJ,QAAAA,SAAAA;EAAuDE,QAAAA,WAAAA;EAA+BL,WAAAA,CAAAA,OAAAA,EAAtFG,eAAsFH,CAAtEO,WAAsEP,CAAAA,GAAAA,SAAAA,EAAAA,WAAAA,EAA/BK,WAA+BL,EAAAA,OAAAA,CAAAA,EAARQ,OAAQR,CAAAA,kBAAAA,CAAAA,EAAAA,aAAAA,CAAAA,EAAqCC,iBAArCD,EAAAA,kBAAAA,CAAAA,EAAAA,OAAAA;EAARQ,QAAAA,aAAAA;EAA6CP,UAAAA,CAAAA,OAAAA,EAE5HE,eAF4HF,CAE5GM,WAF4GN,CAAAA,GAAAA,SAAAA,CAAAA,EAAAA,IAAAA;EAE5GM,gBAAAA,CAAAA,CAAAA,EAAAA,IAAAA;EAAhBJ,QAAAA,EAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,GAAAA,OAAAA;EAIqBJ,OAAAA,CAAAA,CAAAA,EAAAA,IAAAA;EAGhCU,UAAAA,CAAAA,SAAAA,EAAAA,MAAAA,EAAAA,SAAAA,EAHgCV,mBAGhCU,CAAAA,EAAAA,IAAAA;EAAeC,aAAAA,CAAAA,OAAAA,EAAAA,OAAAA,CAAAA,EAAAA,IAAAA;EAASC,QAAAA,sBAAAA;EAASC,MAAAA,CAAAA;IAAAA,aAAAA;IAAAA,OAAAA;IAAAA,OAAAA;IAAAA,QAAAA;IAAAA,GAAAA;EAAAA,CAAAA,CAAAA,EAAuBR,mBAAvBQ,CAA2CL,WAA3CK,CAAAA,CAAAA,EAAAA,OAAAA;EAA2CL,QAAAA,YAAAA;EAApBH,QAAAA,iBAAAA;EAjBKF,QAAAA,oBAAAA;EAAQ,QAAA,4BAAA"}

package/dist/components/VirtualizedFileDiff.js

@@ -0,0 +1,316 @@
+import { DEFAULT_COLLAPSED_CONTEXT_THRESHOLD } from "../constants.js";
+import { iterateOverDiff } from "../utils/iterateOverDiff.js";
+import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
+import { FileDiff } from "./FileDiff.js";
+import { resolveVirtualFileMetrics } from "../utils/resolveVirtualFileMetrics.js";
+
+//#region src/components/VirtualizedFileDiff.ts
+let instanceId = -1;
+var VirtualizedFileDiff = class extends FileDiff {
+	__id = `little-virtualized-file-diff:${++instanceId}`;
+	top;
+	height = 0;
+	metrics;
+	heightCache = /* @__PURE__ */ new Map();
+	isVisible = false;
+	virtualizer;
+	constructor(options, virtualizer, metrics, workerManager, isContainerManaged = false) {
+		super(options, workerManager, isContainerManaged);
+		const { hunkSeparators = "line-info" } = this.options;
+		this.virtualizer = virtualizer;
+		this.metrics = resolveVirtualFileMetrics(typeof hunkSeparators === "function" ? "custom" : hunkSeparators, metrics);
+	}
+	getLineHeight(lineIndex, hasMetadataLine = false) {
+		const cached = this.heightCache.get(lineIndex);
+		if (cached != null) return cached;
+		const multiplier = hasMetadataLine ? 2 : 1;
+		return this.metrics.lineHeight * multiplier;
+	}
+	setOptions(options) {
+		if (options == null) return;
+		const previousDiffStyle = this.options.diffStyle;
+		const previousOverflow = this.options.overflow;
+		super.setOptions(options);
+		if (previousDiffStyle !== this.options.diffStyle || previousOverflow !== this.options.overflow) {
+			this.heightCache.clear();
+			this.computeApproximateSize();
+			this.renderRange = void 0;
+		}
+		this.virtualizer.instanceChanged(this);
+	}
+	reconcileHeights() {
+		const { overflow = "scroll" } = this.options;
+		if (this.fileContainer != null) this.top = this.virtualizer.getOffsetInScrollContainer(this.fileContainer);
+		if (this.fileContainer == null || this.fileDiff == null) {
+			this.height = 0;
+			return;
+		}
+		if (overflow === "scroll" && this.lineAnnotations.length === 0 && !this.virtualizer.config.resizeDebugging) return;
+		const diffStyle = this.getDiffStyle();
+		let hasLineHeightChange = false;
+		const codeGroups = diffStyle === "split" ? [this.codeDeletions, this.codeAdditions] : [this.codeUnified];
+		for (const codeGroup of codeGroups) {
+			if (codeGroup == null) continue;
+			const content = codeGroup.children[1];
+			if (!(content instanceof HTMLElement)) continue;
+			for (const line of content.children) {
+				if (!(line instanceof HTMLElement)) continue;
+				const lineIndexAttr = line.dataset.lineIndex;
+				if (lineIndexAttr == null) continue;
+				const lineIndex = parseLineIndex(lineIndexAttr, diffStyle);
+				let measuredHeight = line.getBoundingClientRect().height;
+				let hasMetadata = false;
+				if (line.nextElementSibling instanceof HTMLElement && ("lineAnnotation" in line.nextElementSibling.dataset || "noNewline" in line.nextElementSibling.dataset)) {
+					if ("noNewline" in line.nextElementSibling.dataset) hasMetadata = true;
+					measuredHeight += line.nextElementSibling.getBoundingClientRect().height;
+				}
+				const expectedHeight = this.getLineHeight(lineIndex, hasMetadata);
+				if (measuredHeight === expectedHeight) continue;
+				hasLineHeightChange = true;
+				if (measuredHeight === this.metrics.lineHeight * (hasMetadata ? 2 : 1)) this.heightCache.delete(lineIndex);
+				else this.heightCache.set(lineIndex, measuredHeight);
+			}
+		}
+		if (hasLineHeightChange || this.virtualizer.config.resizeDebugging) this.computeApproximateSize();
+	}
+	onRender = (dirty) => {
+		if (this.fileContainer == null) return false;
+		if (dirty) this.top = this.virtualizer.getOffsetInScrollContainer(this.fileContainer);
+		return this.render();
+	};
+	cleanUp() {
+		if (this.fileContainer != null) this.virtualizer.disconnect(this.fileContainer);
+		super.cleanUp();
+	}
+	expandHunk(hunkIndex, direction) {
+		this.hunksRenderer.expandHunk(hunkIndex, direction);
+		this.computeApproximateSize();
+		this.renderRange = void 0;
+		this.virtualizer.instanceChanged(this);
+	}
+	setVisibility(visible) {
+		if (this.fileContainer == null) return;
+		if (visible && !this.isVisible) {
+			this.top = this.virtualizer.getOffsetInScrollContainer(this.fileContainer);
+			this.isVisible = true;
+		} else if (!visible && this.isVisible) {
+			this.isVisible = false;
+			this.rerender();
+		}
+	}
+	computeApproximateSize() {
+		this.height = 0;
+		if (this.fileDiff == null) return;
+		const { disableFileHeader = false, expandUnchanged = false, collapsedContextThreshold = DEFAULT_COLLAPSED_CONTEXT_THRESHOLD, hunkSeparators = "line-info" } = this.options;
+		const { diffHeaderHeight, fileGap, hunkSeparatorHeight } = this.metrics;
+		const diffStyle = this.getDiffStyle();
+		const separatorGap = hunkSeparators === "simple" || hunkSeparators === "metadata" ? 0 : fileGap;
+		if (!disableFileHeader) this.height += diffHeaderHeight;
+		else if (hunkSeparators !== "simple" && hunkSeparators !== "metadata") this.height += fileGap;
+		iterateOverDiff({
+			diff: this.fileDiff,
+			diffStyle,
+			expandedHunks: expandUnchanged ? true : this.hunksRenderer.getExpandedHunksMap(),
+			collapsedContextThreshold,
+			callback: ({ hunkIndex, collapsedBefore, collapsedAfter, deletionLine, additionLine }) => {
+				const splitLineIndex = additionLine != null ? additionLine.splitLineIndex : deletionLine.splitLineIndex;
+				const unifiedLineIndex = additionLine != null ? additionLine.unifiedLineIndex : deletionLine.unifiedLineIndex;
+				const hasMetadata = (additionLine?.noEOFCR ?? false) || (deletionLine?.noEOFCR ?? false);
+				if (collapsedBefore > 0) {
+					if (hunkIndex > 0) this.height += separatorGap;
+					this.height += hunkSeparatorHeight + separatorGap;
+				}
+				this.height += this.getLineHeight(diffStyle === "split" ? splitLineIndex : unifiedLineIndex, hasMetadata);
+				if (collapsedAfter > 0 && hunkSeparators !== "simple") this.height += separatorGap + hunkSeparatorHeight;
+			}
+		});
+		if (this.fileDiff.hunks.length > 0) this.height += fileGap;
+		if (this.fileContainer != null && this.virtualizer.config.resizeDebugging) {
+			const rect = this.fileContainer.getBoundingClientRect();
+			if (rect.height !== this.height) console.log("VirtualizedFileDiff.computeApproximateSize: computed height doesnt match", {
+				name: this.fileDiff.name,
+				elementHeight: rect.height,
+				computedHeight: this.height
+			});
+			else console.log("VirtualizedFileDiff.computeApproximateSize: computed height IS CORRECT");
+		}
+	}
+	render({ fileContainer, oldFile, newFile, fileDiff,...props } = {}) {
+		const isFirstRender = this.fileContainer == null;
+		this.fileDiff ??= fileDiff ?? (oldFile != null && newFile != null ? parseDiffFromFile(oldFile, newFile) : void 0);
+		fileContainer = this.getOrCreateFileContainer(fileContainer);
+		if (this.fileDiff == null) {
+			console.error("VirtualizedFileDiff.render: attempting to virtually render when we dont have the correct data");
+			return false;
+		}
+		this.top ??= this.virtualizer.getOffsetInScrollContainer(fileContainer);
+		if (isFirstRender) {
+			this.computeApproximateSize();
+			this.virtualizer.connect(fileContainer, this);
+			this.isVisible = this.virtualizer.isInstanceVisible(this.top, this.height);
+		}
+		if (!this.isVisible) return this.renderPlaceholder(this.height);
+		const windowSpecs = this.virtualizer.getWindowSpecs();
+		const renderRange = this.computeRenderRangeFromWindow(this.fileDiff, this.top, windowSpecs);
+		return super.render({
+			fileDiff: this.fileDiff,
+			fileContainer,
+			renderRange,
+			oldFile,
+			newFile,
+			...props
+		});
+	}
+	getDiffStyle() {
+		return this.options.diffStyle ?? "split";
+	}
+	getExpandedRegion(isPartial, hunkIndex, rangeSize) {
+		if (rangeSize <= 0 || isPartial) return {
+			fromStart: 0,
+			fromEnd: 0,
+			collapsedLines: Math.max(rangeSize, 0),
+			renderAll: false
+		};
+		const { expandUnchanged = false, collapsedContextThreshold = DEFAULT_COLLAPSED_CONTEXT_THRESHOLD } = this.options;
+		if (expandUnchanged || rangeSize <= collapsedContextThreshold) return {
+			fromStart: rangeSize,
+			fromEnd: 0,
+			collapsedLines: 0,
+			renderAll: true
+		};
+		const region = this.hunksRenderer.getExpandedHunk(hunkIndex);
+		const fromStart = Math.min(Math.max(region.fromStart, 0), rangeSize);
+		const fromEnd = Math.min(Math.max(region.fromEnd, 0), rangeSize);
+		const expandedCount = fromStart + fromEnd;
+		const renderAll = expandedCount >= rangeSize;
+		return {
+			fromStart,
+			fromEnd,
+			collapsedLines: Math.max(rangeSize - expandedCount, 0),
+			renderAll
+		};
+	}
+	getExpandedLineCount(fileDiff, diffStyle) {
+		let count = 0;
+		if (fileDiff.isPartial) {
+			for (const hunk of fileDiff.hunks) count += diffStyle === "split" ? hunk.splitLineCount : hunk.unifiedLineCount;
+			return count;
+		}
+		for (const [hunkIndex, hunk] of fileDiff.hunks.entries()) {
+			const hunkCount = diffStyle === "split" ? hunk.splitLineCount : hunk.unifiedLineCount;
+			count += hunkCount;
+			const collapsedBefore = Math.max(hunk.collapsedBefore, 0);
+			const { fromStart, fromEnd, renderAll } = this.getExpandedRegion(fileDiff.isPartial, hunkIndex, collapsedBefore);
+			if (collapsedBefore > 0) count += renderAll ? collapsedBefore : fromStart + fromEnd;
+		}
+		const lastHunk = fileDiff.hunks.at(-1);
+		if (lastHunk != null && hasFinalHunk(fileDiff)) {
+			const additionRemaining = fileDiff.additionLines.length - (lastHunk.additionLineIndex + lastHunk.additionCount);
+			const deletionRemaining = fileDiff.deletionLines.length - (lastHunk.deletionLineIndex + lastHunk.deletionCount);
+			if (lastHunk != null && additionRemaining !== deletionRemaining) throw new Error(`VirtualizedFileDiff: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${fileDiff.name}`);
+			const trailingRangeSize = Math.min(additionRemaining, deletionRemaining);
+			if (lastHunk != null && trailingRangeSize > 0) {
+				const { fromStart, renderAll } = this.getExpandedRegion(fileDiff.isPartial, fileDiff.hunks.length, trailingRangeSize);
+				count += renderAll ? trailingRangeSize : fromStart;
+			}
+		}
+		return count;
+	}
+	computeRenderRangeFromWindow(fileDiff, fileTop, { top, bottom }) {
+		const { disableFileHeader = false, expandUnchanged = false, collapsedContextThreshold = DEFAULT_COLLAPSED_CONTEXT_THRESHOLD, hunkSeparators = "line-info" } = this.options;
+		const { diffHeaderHeight, fileGap, hunkLineCount, hunkSeparatorHeight, lineHeight } = this.metrics;
+		const diffStyle = this.getDiffStyle();
+		const fileHeight = this.height;
+		const lineCount = this.getExpandedLineCount(fileDiff, diffStyle);
+		const headerRegion = disableFileHeader ? fileGap : diffHeaderHeight;
+		if (fileTop < top - fileHeight || fileTop > bottom) return {
+			startingLine: 0,
+			totalLines: 0,
+			bufferBefore: 0,
+			bufferAfter: fileHeight - headerRegion - fileGap
+		};
+		if (lineCount <= hunkLineCount || fileDiff.hunks.length === 0) return {
+			startingLine: 0,
+			totalLines: hunkLineCount,
+			bufferBefore: 0,
+			bufferAfter: 0
+		};
+		const estimatedTargetLines = Math.ceil(Math.max(bottom - top, 0) / lineHeight);
+		const totalLines = Math.ceil(estimatedTargetLines / hunkLineCount) * hunkLineCount + hunkLineCount;
+		const totalHunks = totalLines / hunkLineCount;
+		const overflowHunks = totalHunks;
+		const hunkOffsets = [];
+		const viewportCenter = (top + bottom) / 2;
+		const separatorGap = hunkSeparators === "simple" || hunkSeparators === "metadata" ? 0 : fileGap;
+		let absoluteLineTop = fileTop + headerRegion;
+		let currentLine = 0;
+		let firstVisibleHunk;
+		let centerHunk;
+		let overflowCounter;
+		iterateOverDiff({
+			diff: fileDiff,
+			diffStyle,
+			expandedHunks: expandUnchanged ? true : this.hunksRenderer.getExpandedHunksMap(),
+			collapsedContextThreshold,
+			callback: ({ hunkIndex, collapsedBefore, collapsedAfter, deletionLine, additionLine }) => {
+				const splitLineIndex = additionLine != null ? additionLine.splitLineIndex : deletionLine.splitLineIndex;
+				const unifiedLineIndex = additionLine != null ? additionLine.unifiedLineIndex : deletionLine.unifiedLineIndex;
+				const hasMetadata = (additionLine?.noEOFCR ?? false) || (deletionLine?.noEOFCR ?? false);
+				let gapAdjustment = collapsedBefore > 0 ? hunkSeparatorHeight + separatorGap + (hunkIndex > 0 ? separatorGap : 0) : 0;
+				if (hunkIndex === 0 && hunkSeparators === "simple") gapAdjustment = 0;
+				absoluteLineTop += gapAdjustment;
+				const isAtHunkBoundary = currentLine % hunkLineCount === 0;
+				if (isAtHunkBoundary) {
+					hunkOffsets.push(absoluteLineTop - (fileTop + headerRegion + gapAdjustment));
+					if (overflowCounter != null) {
+						if (overflowCounter <= 0) return true;
+						overflowCounter--;
+					}
+				}
+				const lineHeight$1 = this.getLineHeight(diffStyle === "split" ? splitLineIndex : unifiedLineIndex, hasMetadata);
+				const currentHunk = Math.floor(currentLine / hunkLineCount);
+				if (absoluteLineTop > top - lineHeight$1 && absoluteLineTop < bottom) firstVisibleHunk ??= currentHunk;
+				if (centerHunk == null && absoluteLineTop + lineHeight$1 > viewportCenter) centerHunk = currentHunk;
+				if (overflowCounter == null && absoluteLineTop >= bottom && isAtHunkBoundary) overflowCounter = overflowHunks;
+				currentLine++;
+				absoluteLineTop += lineHeight$1;
+				if (collapsedAfter > 0 && hunkSeparators !== "simple") absoluteLineTop += hunkSeparatorHeight + fileGap;
+				return false;
+			}
+		});
+		if (firstVisibleHunk == null) return {
+			startingLine: 0,
+			totalLines: 0,
+			bufferBefore: 0,
+			bufferAfter: fileHeight - headerRegion - fileGap
+		};
+		const collectedHunks = hunkOffsets.length;
+		centerHunk ??= firstVisibleHunk;
+		const idealStartHunk = Math.round(centerHunk - totalHunks / 2);
+		const maxStartHunk = Math.max(0, collectedHunks - totalHunks);
+		const startHunk = Math.max(0, Math.min(idealStartHunk, maxStartHunk));
+		const startingLine = startHunk * hunkLineCount;
+		const clampedTotalLines = idealStartHunk < 0 ? totalLines + idealStartHunk * hunkLineCount : totalLines;
+		const bufferBefore = hunkOffsets[startHunk] ?? 0;
+		const finalHunkIndex = startHunk + clampedTotalLines / hunkLineCount;
+		return {
+			startingLine,
+			totalLines: clampedTotalLines,
+			bufferBefore,
+			bufferAfter: finalHunkIndex < hunkOffsets.length ? fileHeight - headerRegion - hunkOffsets[finalHunkIndex] - fileGap : fileHeight - (absoluteLineTop - fileTop) - fileGap
+		};
+	}
+};
+function hasFinalHunk(fileDiff) {
+	const lastHunk = fileDiff.hunks.at(-1);
+	if (lastHunk == null || fileDiff.isPartial || fileDiff.additionLines.length === 0 || fileDiff.deletionLines.length === 0) return false;
+	return lastHunk.additionLineIndex + lastHunk.additionCount < fileDiff.additionLines.length || lastHunk.deletionLineIndex + lastHunk.deletionCount < fileDiff.deletionLines.length;
+}
+function parseLineIndex(lineIndexAttr, diffStyle) {
+	const [unifiedIndex, splitIndex] = lineIndexAttr.split(",").map(Number);
+	return diffStyle === "split" ? splitIndex : unifiedIndex;
+}
+
+//#endregion
+export { VirtualizedFileDiff };
+//# sourceMappingURL=VirtualizedFileDiff.js.map