@pierre/diffs 1.1.20 → 1.2.0-beta.1

package/dist/components/CodeView.js

@@ -0,0 +1,1252 @@
+import { DEFAULT_CODE_VIEW_FILE_METRICS, DEFAULT_CODE_VIEW_METRICS, DEFAULT_SMOOTH_SCROLL_SETTINGS, DEFAULT_THEMES, DIFFS_TAG_NAME } from "../constants.js";
+import { dequeueRender, queueRender } from "../managers/UniversalRenderingManager.js";
+import { areObjectsEqual } from "../utils/areObjectsEqual.js";
+import { areSelectionsEqual } from "../utils/areSelectionsEqual.js";
+import { createWindowFromScrollPosition } from "../utils/createWindowFromScrollPosition.js";
+import { roundToDevicePixel } from "../utils/roundToDevicePixel.js";
+import { VirtualizedFile } from "./VirtualizedFile.js";
+import { VirtualizedFileDiff } from "./VirtualizedFileDiff.js";
+
+//#region src/components/CodeView.ts
+const CODE_VIEW_DIFF_OPTION_KEYS = [
+	"theme",
+	"disableLineNumbers",
+	"overflow",
+	"themeType",
+	"disableFileHeader",
+	"disableVirtualizationBuffers",
+	"preferredHighlighter",
+	"useCSSClasses",
+	"useTokenTransformer",
+	"tokenizeMaxLineLength",
+	"tokenizeMaxLength",
+	"unsafeCSS",
+	"diffStyle",
+	"diffIndicators",
+	"disableBackground",
+	"expandUnchanged",
+	"collapsedContextThreshold",
+	"lineDiffType",
+	"maxLineDiffLength",
+	"expansionLineCount",
+	"lineHoverHighlight",
+	"enableTokenInteractionsOnWhitespace",
+	"enableGutterUtility",
+	"__debugPointerEvents",
+	"enableLineSelection",
+	"controlledSelection",
+	"disableErrorHandling"
+];
+const CODE_VIEW_FILE_OPTION_KEYS = [
+	"theme",
+	"disableLineNumbers",
+	"overflow",
+	"themeType",
+	"disableFileHeader",
+	"disableVirtualizationBuffers",
+	"preferredHighlighter",
+	"useCSSClasses",
+	"useTokenTransformer",
+	"tokenizeMaxLineLength",
+	"tokenizeMaxLength",
+	"unsafeCSS",
+	"lineHoverHighlight",
+	"enableTokenInteractionsOnWhitespace",
+	"enableGutterUtility",
+	"__debugPointerEvents",
+	"enableLineSelection",
+	"controlledSelection",
+	"disableErrorHandling"
+];
+const CODE_VIEW_SHARED_CALLBACK_KEYS = [
+	"renderCustomHeader",
+	"renderHeaderPrefix",
+	"renderHeaderMetadata",
+	"renderAnnotation",
+	"renderGutterUtility",
+	"onPostRender",
+	"onGutterUtilityClick",
+	"onLineClick",
+	"onLineNumberClick",
+	"onLineEnter",
+	"onLineLeave",
+	"onTokenClick",
+	"onTokenEnter",
+	"onTokenLeave"
+];
+const CODE_VIEW_SELECTION_CALLBACK_KEYS = [
+	"onLineSelected",
+	"onLineSelectionStart",
+	"onLineSelectionChange",
+	"onLineSelectionEnd"
+];
+const DEFAULT_POINTER_EVENTS_RESTORE_DELAY_MS = 120;
+var CodeView = class CodeView {
+	static __STOP = false;
+	static __lastScrollPosition = 0;
+	type = "advanced";
+	config = {
+		overscrollSize: 200,
+		intersectionObserverMargin: 0,
+		resizeDebugging: false
+	};
+	items = [];
+	idToItem = /* @__PURE__ */ new Map();
+	selectedLines = null;
+	instanceToItem = /* @__PURE__ */ new Map();
+	layoutDirtyIndex;
+	slotCoordinator;
+	slotSnapshot;
+	scrollListeners = /* @__PURE__ */ new Set();
+	scrollHeight = 0;
+	containerHeight = -1;
+	scrollTop = 0;
+	scrollDirty = true;
+	pointerEventsRestoreTimer;
+	pointerEventsDisabled = false;
+	height = 0;
+	heightDirty = true;
+	windowSpecs = {
+		top: 0,
+		bottom: 0
+	};
+	renderState = {
+		scrollTop: -1,
+		firstIndex: -1,
+		lastIndex: -1,
+		stickyHeight: 0,
+		stickyTop: -1,
+		stickyBottom: -1
+	};
+	pendingScrollTarget;
+	pendingLayoutAnchor;
+	scrollAnimation;
+	root;
+	resizeObserver;
+	container = document.createElement("div");
+	stickyContainer = document.createElement("div");
+	stickyOffset = document.createElement("div");
+	options;
+	workerManager;
+	isContainerManaged;
+	constructor(options = { theme: DEFAULT_THEMES }, workerManager, isContainerManaged = false) {
+		this.options = options;
+		this.workerManager = workerManager;
+		this.isContainerManaged = isContainerManaged;
+		this.stickyOffset.style.contain = "layout size";
+		this.stickyContainer.style.position = "sticky";
+		this.stickyContainer.style.width = "100%";
+		this.stickyContainer.style.contain = "layout style inline-size";
+		this.stickyContainer.style.isolation = "isolate";
+		this.stickyContainer.style.display = "flex";
+		this.stickyContainer.style.flexDirection = "column";
+	}
+	getViewerMetrics() {
+		return this.options.viewerMetrics ?? DEFAULT_CODE_VIEW_METRICS;
+	}
+	getItemMetrics() {
+		return this.options.itemMetrics ?? DEFAULT_CODE_VIEW_FILE_METRICS;
+	}
+	getSmoothScrollSettings() {
+		return this.options.smoothScrollSettings ?? DEFAULT_SMOOTH_SCROLL_SETTINGS;
+	}
+	shouldDisablePointerEvents() {
+		return this.options.pointerEventsOnScroll !== true;
+	}
+	clearPointerEventsTimer() {
+		if (this.pointerEventsRestoreTimer != null) {
+			clearTimeout(this.pointerEventsRestoreTimer);
+			this.pointerEventsRestoreTimer = void 0;
+		}
+	}
+	suspendPointerEvents() {
+		if (!this.shouldDisablePointerEvents()) return;
+		this.clearPointerEventsTimer();
+		if (!this.pointerEventsDisabled) {
+			this.stickyContainer.style.pointerEvents = "none";
+			this.pointerEventsDisabled = true;
+		}
+		this.pointerEventsRestoreTimer = setTimeout(this.restorePointerEvents, DEFAULT_POINTER_EVENTS_RESTORE_DELAY_MS);
+	}
+	restorePointerEvents = () => {
+		this.clearPointerEventsTimer();
+		if (!this.pointerEventsDisabled) return;
+		this.stickyContainer.style.removeProperty("pointer-events");
+		this.pointerEventsDisabled = false;
+	};
+	syncViewerMetrics() {
+		const { gap, paddingBottom, paddingTop } = this.getViewerMetrics();
+		this.stickyContainer.style.gap = `${gap}px`;
+		this.container?.style.setProperty("margin-top", `${paddingTop}px`);
+		this.container?.style.setProperty("margin-bottom", `${paddingBottom}px`);
+	}
+	setup(root) {
+		if (this.root != null) throw new Error("CodeView.setup: already setup");
+		this.root = root;
+		this.root.style.overflowAnchor = "none";
+		this.container ??= document.createElement("div");
+		this.container.style.contain = "layout size style";
+		this.syncViewerMetrics();
+		this.container.appendChild(this.stickyOffset);
+		this.container.appendChild(this.stickyContainer);
+		this.root.appendChild(this.container);
+		this.scrollDirty = true;
+		this.heightDirty = true;
+		this.resizeObserver = new ResizeObserver(this.handleResize);
+		this.resizeObserver.observe(this.stickyContainer);
+		this.root.addEventListener("scroll", this.handleScroll, { passive: true });
+		this.root.addEventListener("wheel", this.clearPendingScroll, { passive: true });
+		this.root.addEventListener("touchstart", this.clearPendingScroll, { passive: true });
+		this.root.addEventListener("pointerdown", this.clearPendingScroll, { passive: true });
+		this.root.addEventListener("keydown", this.clearPendingScroll, { passive: true });
+		this.resizeObserver.observe(this.root);
+		this.render(true);
+		window.__INSTANCE = this;
+		window.__TOGGLE = () => {
+			if (CodeView.__STOP) {
+				CodeView.__STOP = false;
+				this.scrollTo({
+					type: "position",
+					position: CodeView.__lastScrollPosition,
+					behavior: "instant"
+				});
+			} else {
+				CodeView.__lastScrollPosition = this.getScrollTop();
+				CodeView.__STOP = true;
+			}
+		};
+	}
+	reset() {
+		this.restorePointerEvents();
+		this.cleanAllRenderedItems();
+		this.selectedLines = null;
+		this.items.length = 0;
+		this.idToItem.clear();
+		this.instanceToItem.clear();
+		this.layoutDirtyIndex = void 0;
+		this.stickyContainer.textContent = "";
+		this.stickyOffset.style.height = "";
+		this.container?.style.removeProperty("height");
+		this.windowSpecs = {
+			top: 0,
+			bottom: 0
+		};
+		this.pendingLayoutAnchor = void 0;
+		this.height = 0;
+		this.scrollTop = 0;
+		this.scrollHeight = 0;
+		this.scrollDirty = true;
+		this.heightDirty = true;
+		this.resetRenderState();
+		if (!this.isContainerManaged) this.flushSlotCoordinator();
+	}
+	cleanUp() {
+		this.reset();
+		this.restorePointerEvents();
+		this.resizeObserver?.disconnect();
+		this.resizeObserver = void 0;
+		this.root?.removeEventListener("scroll", this.handleScroll);
+		this.root?.removeEventListener("wheel", this.clearPendingScroll);
+		this.root?.removeEventListener("touchstart", this.clearPendingScroll);
+		this.root?.removeEventListener("pointerdown", this.clearPendingScroll);
+		this.root?.removeEventListener("keydown", this.clearPendingScroll);
+		this.root?.style.removeProperty("overflow-anchor");
+		this.container?.remove();
+		this.stickyOffset.remove();
+		this.stickyContainer.remove();
+		this.stickyContainer.textContent = "";
+		this.root = void 0;
+		this.container = void 0;
+	}
+	cleanAllRenderedItems() {
+		if (this.renderState.firstIndex === -1) return;
+		for (let index = this.renderState.firstIndex; index <= this.renderState.lastIndex; index++) {
+			const item = this.items[index];
+			if (item == null) throw new Error(`CodeView.cleanAllRenderedItems: Item does not exist at index: ${index}`);
+			cleanRenderedItem(item);
+		}
+	}
+	resolveEffectiveScrollBehavior(target, destination) {
+		if (target.behavior !== "smooth-auto") return target.behavior ?? "instant";
+		return Math.abs(destination - this.getScrollTop()) <= this.getHeight() * 10 ? "smooth" : "instant";
+	}
+	scrollTo(target) {
+		if (this.root == null) return;
+		const pendingTarget = this.normalizeScrollTarget(target);
+		if (pendingTarget == null) return;
+		const destination = this.resolveScrollTargetTop(pendingTarget);
+		if (destination == null) return;
+		if (this.resolveEffectiveScrollBehavior(pendingTarget, destination) === "smooth") this.scrollAnimation ??= {
+			position: this.getScrollTop(),
+			velocity: 0,
+			lastTimestamp: performance.now()
+		};
+		else this.scrollAnimation = void 0;
+		this.suspendPointerEvents();
+		this.pendingLayoutAnchor = void 0;
+		this.pendingScrollTarget = pendingTarget;
+		this.render();
+	}
+	setSelectedLines(selection, options) {
+		this.applySelectedLines(selection, options);
+	}
+	getSelectedLines() {
+		return this.selectedLines;
+	}
+	clearSelectedLines(options) {
+		this.applySelectedLines(null, options);
+	}
+	addItem(input) {
+		this.addItems([input]);
+		this.syncSelection();
+	}
+	addItems(inputs) {
+		this.appendItemsInternal(inputs);
+		this.syncSelection();
+	}
+	setItems(items) {
+		if (items.length === 0) this.reset();
+		else if (this.items.length === 0) this.appendItemsInternal(items);
+		else if (!this.tryAppendItems(items)) this.reconcileItems(items);
+		this.syncSelection();
+	}
+	/**
+	* Append new records to the viewer while preserving existing layout state.
+	* This is the shared path for imperative adds and the append-only reconcile
+	* fast path, so it measures new items immediately and only triggers render
+	* once at the end.
+	*/
+	appendItemsInternal(inputs, render = true) {
+		if (inputs.length === 0) return;
+		const viewerMetrics = this.getViewerMetrics();
+		let nextTop = this.items.length === 0 ? 0 : this.scrollHeight + viewerMetrics.gap;
+		for (let index = 0; index < inputs.length; index++) {
+			const input = inputs[index];
+			if (input == null) throw new Error("CodeView.appendItemsInternal: missing input item");
+			if (this.idToItem.has(input.id)) throw new Error(`CodeView.addItem: duplicate id "${input.id}"`);
+			const item = this.createItem(input, this.items.length, nextTop);
+			this.items.push(item);
+			this.idToItem.set(item.item.id, item);
+			this.instanceToItem.set(item.instance, item);
+			item.height = prepareItemInstance(item);
+			nextTop += item.height + viewerMetrics.gap;
+		}
+		this.scrollHeight = nextTop - viewerMetrics.gap;
+		this.scrollDirty = true;
+		if (render) this.render();
+	}
+	setOptions(options) {
+		if (options == null) return;
+		this.capturePendingLayoutAnchor();
+		const previousViewerMetrics = this.getViewerMetrics();
+		const previousItemMetrics = this.getItemMetrics();
+		this.options = options;
+		const nextItemMetrics = this.getItemMetrics();
+		const itemMetricsChanged = !areObjectsEqual(previousItemMetrics, nextItemMetrics);
+		if (!areObjectsEqual(previousViewerMetrics, this.getViewerMetrics())) this.syncViewerMetrics();
+		for (let index = 0; index < this.items.length; index++) {
+			const item = this.items[index];
+			if (item == null) throw new Error("CodeView.setOptions: invalid item index");
+			if (itemMetricsChanged) item.instance.setMetrics(nextItemMetrics, true);
+			if (item.type === "diff") item.instance.setOptions(this.createOptions(item.item));
+			else item.instance.setOptions(this.createOptions(item.item));
+		}
+		this.markLayoutDirtyFromIndex(0);
+		this.scrollDirty = true;
+		if (!this.isContainerManaged && this.items.length > 0) this.render();
+	}
+	capturePendingLayoutAnchor() {
+		if (this.root == null || this.items.length === 0 || this.pendingScrollTarget != null) return;
+		this.pendingLayoutAnchor = this.getScrollAnchor(this.getScrollTop());
+	}
+	render(immediate = false) {
+		if (CodeView.__STOP) return;
+		if (immediate) {
+			dequeueRender(this.computeRenderRangeAndEmit);
+			this.computeRenderRangeAndEmit();
+		} else queueRender(this.computeRenderRangeAndEmit);
+	}
+	instanceChanged(instance, layoutDirty) {
+		const item = this.instanceToItem.get(instance);
+		if (item == null) throw new Error("CodeView.instanceChanged: An instance has changed that is not registered");
+		if (layoutDirty) this.markItemLayoutDirty(item);
+		this.render();
+	}
+	getWindowSpecs() {
+		return this.windowSpecs;
+	}
+	getContainerElement() {
+		return this.root;
+	}
+	getRenderedItems() {
+		const { firstIndex, lastIndex } = this.renderState;
+		if (firstIndex === -1 || lastIndex === -1 || lastIndex < firstIndex) return [];
+		const renderedItems = [];
+		for (let index = firstIndex; index <= lastIndex; index++) {
+			const item = this.items[index];
+			if (item?.element == null) continue;
+			if (item.type === "diff") renderedItems.push({
+				id: item.item.id,
+				type: "diff",
+				item: item.item,
+				version: item.version,
+				element: item.element,
+				instance: item.instance
+			});
+			else renderedItems.push({
+				id: item.item.id,
+				type: "file",
+				item: item.item,
+				version: item.version,
+				element: item.element,
+				instance: item.instance
+			});
+		}
+		return renderedItems;
+	}
+	setSlotCoordinator(coordinator) {
+		if (coordinator === this.slotCoordinator) return false;
+		this.slotCoordinator = coordinator;
+		this.slotSnapshot = void 0;
+		return true;
+	}
+	getSlotSnapshot(coordinator) {
+		return getSlotSnapshot(this.getRenderedItems(), coordinator);
+	}
+	subscribeToScroll(listener) {
+		this.scrollListeners.add(listener);
+		return () => {
+			this.scrollListeners.delete(listener);
+		};
+	}
+	getTopForInstance(instance) {
+		const item = this.instanceToItem.get(instance);
+		if (item == null) throw new Error("CodeView.getTopForInstance: unknown virtualized instance");
+		return item.top;
+	}
+	getTopForItem(id) {
+		const item = this.idToItem.get(id);
+		if (item == null) return;
+		return item.top;
+	}
+	createItem(input, index, top) {
+		const itemMetrics = this.getItemMetrics();
+		if (input.type === "diff") return {
+			type: "diff",
+			item: input,
+			version: input.version,
+			index,
+			instance: new VirtualizedFileDiff(this.createOptions(input), this, itemMetrics, this.workerManager, this.isContainerManaged),
+			top,
+			height: 0,
+			element: void 0
+		};
+		return {
+			type: "file",
+			item: input,
+			version: input.version,
+			index,
+			instance: new VirtualizedFile(this.createOptions(input), this, itemMetrics, this.workerManager, this.isContainerManaged),
+			top,
+			height: 0,
+			element: void 0
+		};
+	}
+	getItemById(itemId) {
+		const item = this.idToItem.get(itemId);
+		if (item == null) console.error(`CodeView.getItemById: unknown item id "${itemId}"`);
+		return item;
+	}
+	getItemByMode(itemId, mode) {
+		const item = this.getItemById(itemId);
+		if (item == null) return;
+		if (item.type !== mode) {
+			console.error(`CodeView.getItemByMode: item id "${itemId}" is not a ${mode}`);
+			return;
+		}
+		return item;
+	}
+	applySelectedLines(selection, options) {
+		const { selectedLines: prevSelection } = this;
+		if (selection == null && prevSelection == null || selection != null && prevSelection?.id === selection.id && areSelectionsEqual(prevSelection.range, selection.range)) return;
+		if (prevSelection != null && prevSelection.id !== selection?.id) this.idToItem.get(prevSelection.id)?.instance.setSelectedLines(null, { notify: false });
+		this.selectedLines = selection;
+		this.idToItem.get(selection?.id ?? "")?.instance.setSelectedLines(selection?.range ?? null, options);
+	}
+	syncSelection() {
+		if (this.selectedLines == null) return;
+		const item = this.idToItem.get(this.selectedLines.id);
+		if (item == null) {
+			this.selectedLines = null;
+			return;
+		}
+		item.instance.setSelectedLines(this.selectedLines.range, { notify: false });
+	}
+	wrapCallbackWithContext(mode, itemId, callback) {
+		return (...args) => {
+			const item = this.getItemByMode(itemId, mode);
+			if (item == null) return;
+			return callback(...args, item);
+		};
+	}
+	getWrappedOptionCallback(mode, key, itemId) {
+		const callback = this.options[key];
+		if (callback == null) return;
+		return this.wrapCallbackWithContext(mode, itemId, callback);
+	}
+	getWrappedSelectionOptionCallback(mode, key, itemId) {
+		if (this.options.enableLineSelection !== true) return;
+		const callback = this.options[key];
+		return ((range) => {
+			const item = this.getItemByMode(itemId, mode);
+			if (item == null) return;
+			const selection = range == null ? null : {
+				id: itemId,
+				range
+			};
+			if (this.options.controlledSelection !== true) {
+				if (range != null || this.selectedLines?.id === itemId) this.applySelectedLines(selection, { notify: false });
+			}
+			this.options.onSelectedLinesChange?.(selection);
+			return callback?.(range, item);
+		});
+	}
+	createOptions(item) {
+		const { id: itemId, type: mode } = item;
+		const options = mode === "file" ? { stickyHeader: this.options.stickyHeaders } : {
+			stickyHeader: this.options.stickyHeaders,
+			hunkSeparators: this.options.hunkSeparators
+		};
+		const target = options;
+		const passThroughKeys = mode === "file" ? CODE_VIEW_FILE_OPTION_KEYS : CODE_VIEW_DIFF_OPTION_KEYS;
+		for (const key of passThroughKeys) {
+			const value = this.options[key];
+			if (value !== void 0) target[key] = value;
+		}
+		target.collapsed = item.collapsed === true;
+		for (const key of CODE_VIEW_SHARED_CALLBACK_KEYS) {
+			const callback = this.getWrappedOptionCallback(mode, key, itemId);
+			if (callback !== void 0) target[key] = callback;
+		}
+		for (const key of CODE_VIEW_SELECTION_CALLBACK_KEYS) {
+			const callback = this.getWrappedSelectionOptionCallback(mode, key, itemId);
+			if (callback !== void 0) target[key] = callback;
+		}
+		return options;
+	}
+	/**
+	* Track the earliest index whose measured layout may now be stale. Later
+	* render passes relayout from this point forward so we do not have to rebuild
+	* positions for the whole list after every change.
+	*/
+	markLayoutDirtyFromIndex(index) {
+		this.layoutDirtyIndex = Math.min(this.layoutDirtyIndex ?? index, index);
+	}
+	/**
+	* Mark the earliest affected item as layout-dirty after an imperative change.
+	* Each record carries its current array index so this stays O(1) even when
+	* the viewer holds a very large number of items.
+	*/
+	markItemLayoutDirty(item) {
+		if (this.items[item.index] !== item) throw new Error(`CodeView.markItemLayoutDirty: unknown item id "${item.item.id}"`);
+		this.markLayoutDirtyFromIndex(item.index);
+	}
+	/**
+	* Detect the common controlled-update case where the new list simply extends
+	* the existing ordered prefix. When that happens we can reuse every current
+	* record in place, sync any versioned payload changes, and append only the new
+	* tail instead of rebuilding the whole list.
+	*/
+	tryAppendItems(items) {
+		if (items.length <= this.items.length) return false;
+		for (let index = 0; index < this.items.length; index++) {
+			const existingItem = this.items[index];
+			if (existingItem == null) throw new Error("CodeView.tryAppendItems: missing existing item");
+			const nextItem = items[index];
+			if (nextItem == null || existingItem.item.id !== nextItem.id || existingItem.type !== nextItem.type) return false;
+		}
+		for (let index = 0; index < this.items.length; index++) {
+			const existingItem = this.items[index];
+			if (existingItem == null) throw new Error("CodeView.tryAppendItems: missing existing item");
+			const nextItem = items[index];
+			if (nextItem == null) throw new Error("CodeView.tryAppendItems: append candidate missing prefix item");
+			if (this.syncItemRecord(existingItem, nextItem)) this.markLayoutDirtyFromIndex(index);
+		}
+		this.appendItemsInternal(items.slice(this.items.length), false);
+		this.scrollDirty = true;
+		this.render();
+		return true;
+	}
+	/**
+	* Reconcile a new controlled item list against the existing records by id.
+	* This reuses records and instances when type matches, cleans up removed
+	* records, rebuilds the lookup maps, and marks layout dirty whenever order,
+	* membership, or versioned item data changes.
+	*/
+	reconcileItems(items) {
+		const { items: previousItems, idToItem: previousById } = this;
+		const removedItems = new Set(previousItems);
+		const nextItems = [];
+		const nextIdToItem = /* @__PURE__ */ new Map();
+		const nextInstanceToItem = /* @__PURE__ */ new Map();
+		let firstDirtyIndex;
+		for (let index = 0; index < items.length; index++) {
+			const input = items[index];
+			if (input == null) throw new Error("CodeView.reconcileItems: missing input item");
+			if (nextIdToItem.has(input.id)) throw new Error(`CodeView.setItems: duplicate id "${input.id}"`);
+			const previousItem = previousById.get(input.id);
+			const item = previousItem != null && previousItem.type === input.type ? previousItem : this.createItem(input, index, 0);
+			item.index = index;
+			if (previousItem != null && previousItem.type === input.type) {
+				removedItems.delete(previousItem);
+				if (this.syncItemRecord(item, input)) firstDirtyIndex = Math.min(firstDirtyIndex ?? index, index);
+			} else firstDirtyIndex = Math.min(firstDirtyIndex ?? index, index);
+			if (previousItems[index] !== item) firstDirtyIndex = Math.min(firstDirtyIndex ?? index, index);
+			nextItems.push(item);
+			nextIdToItem.set(input.id, item);
+			nextInstanceToItem.set(item.instance, item);
+		}
+		for (let index = 0; index < previousItems.length; index++) {
+			const removedItem = previousItems[index];
+			if (removedItem == null || !removedItems.has(removedItem)) continue;
+			cleanRenderedItem(removedItem);
+			const dirtyIndex = Math.max(nextItems.length - 1, 0);
+			firstDirtyIndex = Math.min(firstDirtyIndex ?? dirtyIndex, dirtyIndex);
+		}
+		if (firstDirtyIndex == null) return;
+		this.items = nextItems;
+		this.idToItem = nextIdToItem;
+		this.instanceToItem = nextInstanceToItem;
+		if (this.renderState.firstIndex >= nextItems.length) this.resetRenderState();
+		else if (this.renderState.lastIndex >= nextItems.length) this.renderState.lastIndex = nextItems.length - 1;
+		this.markLayoutDirtyFromIndex(firstDirtyIndex);
+		this.scrollDirty = true;
+		this.render();
+	}
+	/**
+	* Update a reused record from the latest controlled item only when its item
+	* version changes. Matching versions mean CodeView keeps the current record
+	* snapshot, which lets imperative updates remain in place until the caller
+	* intentionally publishes a newer version.
+	*/
+	syncItemRecord(item, nextItem) {
+		if (item.type !== nextItem.type) throw new Error(`CodeView.syncItemRecord: type mismatch for id "${nextItem.id}"`);
+		if (item.version === nextItem.version) return false;
+		item.item = nextItem;
+		item.version = nextItem.version;
+		if (item.type === "diff") item.instance.setOptions(this.createOptions(item.item));
+		else item.instance.setOptions(this.createOptions(item.item));
+		return true;
+	}
+	/**
+	* Clamps a scroll position to the min/max allowable scroll range based on
+	* the computed total height
+	*/
+	clampScrollTop(value) {
+		const { paddingBottom, paddingTop } = this.getViewerMetrics();
+		const maxScroll = Math.max(paddingTop + this.getScrollHeight() + paddingBottom - this.getHeight(), 0);
+		return Math.max(0, Math.min(value, maxScroll));
+	}
+	getStickyHeaderOffset() {
+		return this.options.stickyHeaders === true && this.options.disableFileHeader !== true ? this.getItemMetrics().diffHeaderHeight : 0;
+	}
+	getScrollTargetRect(target) {
+		const item = this.idToItem.get(target.id);
+		if (item == null) {
+			console.warn(`CodeView.scrollTo: unknown item id "${target.id}"`);
+			return;
+		}
+		if (target.type === "item") return {
+			top: item.top,
+			height: item.height
+		};
+		const linePosition = this.getLineScrollPosition(item, target);
+		if (linePosition == null) {
+			console.warn(`CodeView.scrollTo: unable to resolve line ${target.lineNumber} for item "${target.id}"`);
+			return;
+		}
+		return {
+			top: item.top + linePosition.top,
+			height: linePosition.height
+		};
+	}
+	normalizeScrollTarget(target) {
+		if (target.type === "position" || target.align !== "nearest") return target;
+		const rect = this.getScrollTargetRect(target);
+		if (rect == null) return;
+		const offset = target.offset ?? 0;
+		const targetTop = this.getViewerMetrics().paddingTop + rect.top;
+		const targetBottom = targetTop + rect.height;
+		const currentTop = this.getScrollTop();
+		const visibleTop = currentTop + (target.type === "line" ? this.getStickyHeaderOffset() : 0);
+		const visibleBottom = currentTop + this.getHeight();
+		if (targetTop - offset <= visibleTop && targetBottom + offset >= visibleBottom) return;
+		if (targetTop - offset < visibleTop) return {
+			...target,
+			align: "start"
+		};
+		if (targetBottom + offset > visibleBottom) return {
+			...target,
+			align: "end"
+		};
+	}
+	/**
+	* Resolve a target's scroll position
+	
+	* Returns `undefined` when we can't resolve a target for whatever reason
+	*/
+	resolveScrollTargetTop(target) {
+		if (target.type === "position") {
+			const clampedPosition = this.clampScrollTop(target.position);
+			return clampedPosition !== target.position ? clampedPosition : this.clampScrollTop(target.position - this.getStickyHeaderOffset());
+		}
+		const item = this.idToItem.get(target.id);
+		if (item == null) {
+			console.warn(`CodeView.scrollTo: unknown item id "${target.id}"`);
+			return;
+		}
+		if (target.type === "item") return this.clampScrollTop(this.resolveAlignedScrollPosition(item.top, item.height, target.align, target.offset));
+		const linePosition = this.getLineScrollPosition(item, target);
+		if (linePosition == null) {
+			console.warn(`CodeView.scrollTo: unable to resolve line ${target.lineNumber} for item "${target.id}"`);
+			return;
+		}
+		return this.clampScrollTop(this.resolveAlignedScrollPosition(item.top + linePosition.top, linePosition.height, target.align, target.offset, this.getStickyHeaderOffset()));
+	}
+	/**
+	* Given an existing scroll target (scroll top and height), figure out the
+	* correct scroll position to target based on the desired alignment, offset
+	* and stickyOffset if necessary
+	*/
+	resolveAlignedScrollPosition(targetTop, targetHeight, align, offset = 0, stickyOffset = 0) {
+		targetTop += this.getViewerMetrics().paddingTop;
+		const viewportHeight = this.getHeight();
+		if (align === "center" && targetHeight + offset < viewportHeight) return targetTop - (viewportHeight - targetHeight) / 2 + offset;
+		if (align === "end") return targetTop - (viewportHeight - targetHeight) + offset;
+		return targetTop - stickyOffset - offset;
+	}
+	getLineScrollPosition(item, target) {
+		if (item.type === "diff") return item.instance.getLinePosition(target.lineNumber, target.side);
+		return item.instance.getLinePosition(target.lineNumber);
+	}
+	/**
+	* Determine target scroll position for current frame.
+	*
+	* If there's no pendingScrollTarget then we just return the current scroll
+	* position
+	*
+	* If there's a pendingScrollTarget then we depend on whether there's a
+	* smooth scroll animation or not. If not just return the destination, or
+	* compute next position given the smooth scroll spring physics
+	*/
+	computeFrameScrollTop(scrollTop, frameTimestamp) {
+		if (this.pendingScrollTarget == null) return scrollTop;
+		const destination = this.resolveScrollTargetTop(this.pendingScrollTarget);
+		if (destination == null) return scrollTop;
+		const { scrollAnimation } = this;
+		if (scrollAnimation == null) return destination;
+		return this.computeSpringStep(scrollAnimation, destination, frameTimestamp).position;
+	}
+	/**
+	* Closed-form critical-damped ODE step.
+	*
+	* Stable at any dt (Euler would blow up once ω·dt ≳ 1), so this survives
+	* big RAF gaps (tab-wake, offscreen frames) and resize-driven ticks that
+	* fire outside the normal RAF cadence.
+	*/
+	computeSpringStep(animation, destination, frameTimestamp) {
+		const dt = Math.max(0, frameTimestamp - animation.lastTimestamp);
+		const { omega } = this.getSmoothScrollSettings();
+		const decay = Math.exp(-omega * dt);
+		const displacement = animation.position - destination;
+		const springCoeff = animation.velocity + omega * displacement;
+		return {
+			position: destination + (displacement + springCoeff * dt) * decay,
+			velocity: (springCoeff * (1 - omega * dt) - omega * displacement) * decay
+		};
+	}
+	/**
+	* For any given pendingScrollTarget, updates any in flight smooth scroll
+	* animations and returns the target scrollTop to move towards
+	*
+	* Resolves the animation based on frame time and adopts any necessary scroll
+	* anchoring corrections if necessary
+	*/
+	advanceScrollAnimation(frameTimestamp, anchorDelta) {
+		if (this.pendingScrollTarget == null) return;
+		const destination = this.resolveScrollTargetTop(this.pendingScrollTarget);
+		if (destination == null) {
+			this.pendingScrollTarget = void 0;
+			this.scrollAnimation = void 0;
+			return;
+		}
+		const animation = this.scrollAnimation;
+		if (animation == null) return destination;
+		animation.position += anchorDelta;
+		const { position, velocity } = this.computeSpringStep(animation, destination, frameTimestamp);
+		animation.lastTimestamp = frameTimestamp;
+		animation.position = position;
+		animation.velocity = velocity;
+		const { positionEpsilon, velocityEpsilon } = this.getSmoothScrollSettings();
+		if (Math.abs(destination - position) <= positionEpsilon && Math.abs(velocity) <= velocityEpsilon) {
+			animation.position = destination;
+			animation.velocity = 0;
+			this.scrollAnimation = void 0;
+			return destination;
+		}
+		return animation.position;
+	}
+	computeRenderRangeAndEmit = (timestamp = performance.now()) => {
+		if (CodeView.__STOP || this.container == null) return;
+		const height = this.getHeight();
+		let currentScrollTop = this.getScrollTop();
+		const currentRootScrollTop = currentScrollTop;
+		let recomputeScrollTop = this.pendingLayoutAnchor != null;
+		let anchor = this.getScrollAnchor(currentScrollTop);
+		if (this.layoutDirtyIndex != null) {
+			this.recomputeLayout(this.layoutDirtyIndex);
+			this.layoutDirtyIndex = void 0;
+			recomputeScrollTop = true;
+		}
+		if (recomputeScrollTop && anchor != null) {
+			const newScrollTop = this.resolveAnchoredScrollTop(anchor);
+			if (newScrollTop != null) {
+				const delta = newScrollTop - currentScrollTop;
+				currentScrollTop = newScrollTop;
+				if (this.scrollAnimation != null) this.scrollAnimation.position += delta;
+			}
+		}
+		if (recomputeScrollTop) {
+			currentScrollTop = this.clampScrollTop(currentScrollTop);
+			this.syncContainerHeight();
+		}
+		const frameScrollTop = this.computeFrameScrollTop(currentScrollTop, timestamp);
+		const fitPerfectly = !recomputeScrollTop && (this.renderState.scrollTop === -1 || Math.abs(frameScrollTop - this.renderState.scrollTop) > height + this.config.overscrollSize * 2);
+		let appliedScrollTop = currentRootScrollTop;
+		if (this.pendingScrollTarget != null && frameScrollTop !== appliedScrollTop) {
+			this.applyScrollFix(frameScrollTop, appliedScrollTop);
+			appliedScrollTop = frameScrollTop;
+		}
+		if (fitPerfectly) anchor = void 0;
+		this.windowSpecs = createWindowFromScrollPosition({
+			scrollTop: frameScrollTop,
+			height,
+			scrollHeight: this.getScrollHeight(),
+			fitPerfectly,
+			fitPerfectlyOverscroll: this.getFitPerfectlyOverscroll(),
+			overscrollSize: this.config.overscrollSize
+		});
+		const { top, bottom } = this.windowSpecs;
+		const { firstIndex, lastIndex } = this.renderState;
+		if (firstIndex >= 0) for (let index = firstIndex; index <= lastIndex; index++) {
+			const item = this.items[index];
+			if (item == null) throw new Error(`CodeView.computeRenderRangeAndEmit: No item at index: ${index}`);
+			const renderedTop = item.top;
+			if (!(renderedTop > top - item.height && renderedTop <= bottom)) cleanRenderedItem(item);
+		}
+		let prevElement;
+		const updatedItems = /* @__PURE__ */ new Set();
+		const startingIndex = this.findFirstVisibleIndex(top);
+		const lastRenderedIndex = this.findLastVisibleIndex(bottom);
+		for (let itemIndex = startingIndex; itemIndex <= lastRenderedIndex; itemIndex++) {
+			const item = this.items[itemIndex];
+			if (item == null) throw new Error(`CodeView.computeRenderRangeAndEmit: missing item`);
+			const { instance } = item;
+			if (item.element == null) {
+				item.element = document.createElement(DIFFS_TAG_NAME);
+				syncRenderedItemOrder(this.stickyContainer, item.element, prevElement);
+				instance.virtualizedSetup();
+				if (renderItem(item, item.element)) updatedItems.add(item);
+				prevElement = item.element;
+			} else {
+				syncRenderedItemOrder(this.stickyContainer, item.element, prevElement);
+				if (renderItem(item)) updatedItems.add(item);
+				prevElement = item.element;
+			}
+		}
+		this.renderState.firstIndex = startingIndex <= lastRenderedIndex ? startingIndex : -1;
+		this.renderState.lastIndex = lastRenderedIndex;
+		this.flushSlotCoordinator();
+		this.reconcileRenderedItems(updatedItems);
+		this.syncContainerHeight();
+		this.updateStickyPositioning();
+		const anchoredScrollTop = anchor != null ? this.resolveAnchoredScrollTop(anchor) : void 0;
+		if (anchor === this.pendingLayoutAnchor) this.pendingLayoutAnchor = void 0;
+		const anchorScrollDelta = anchoredScrollTop != null ? anchoredScrollTop - currentScrollTop : 0;
+		let renderedScrollTop = frameScrollTop;
+		if (this.pendingScrollTarget == null) {
+			renderedScrollTop = anchoredScrollTop ?? frameScrollTop;
+			if (renderedScrollTop !== appliedScrollTop) this.applyScrollFix(renderedScrollTop, appliedScrollTop);
+		} else if (this.pendingScrollTarget != null) {
+			const targetScrollTop = this.advanceScrollAnimation(timestamp, anchorScrollDelta);
+			if (targetScrollTop != null) {
+				if (targetScrollTop !== appliedScrollTop) this.applyScrollFix(targetScrollTop, appliedScrollTop);
+				renderedScrollTop = targetScrollTop;
+				if (this.pendingScrollTarget != null && this.isPendingTargetSettled(this.pendingScrollTarget)) {
+					this.pendingScrollTarget = void 0;
+					this.scrollAnimation = void 0;
+				}
+			} else renderedScrollTop = currentScrollTop;
+		}
+		this.renderState.scrollTop = roundToDevicePixel(renderedScrollTop);
+		this.flushManagers(updatedItems);
+		if (fitPerfectly || this.scrollAnimation != null) this.render();
+	};
+	flushManagers(updatedItems) {
+		for (const item of updatedItems) item.instance.flushManagers();
+	}
+	syncContainerHeight() {
+		const totalScrollHeight = this.getScrollHeight();
+		if (this.container == null || this.containerHeight === totalScrollHeight) return;
+		this.container.style.height = `${totalScrollHeight}px`;
+		this.containerHeight = totalScrollHeight;
+	}
+	reconcileRenderedItems(updatedItems) {
+		const { firstIndex, lastIndex } = this.renderState;
+		if (firstIndex === -1) return;
+		let currentTop = -1;
+		let heightChanged = false;
+		for (let index = firstIndex; index < this.items.length; index++) {
+			if (!heightChanged && index > lastIndex) break;
+			const item = this.items[index];
+			if (item == null) throw new Error("CodeView.reconcileRenderedItems: Invalid item");
+			if (currentTop === -1) currentTop = item.top;
+			else if (item.top !== currentTop) {
+				item.top = currentTop;
+				item.instance.syncVirtualizedTop();
+				heightChanged = true;
+			}
+			if (updatedItems == null ? index <= lastIndex : updatedItems.has(item)) {
+				if (item.instance.reconcileHeights()) {
+					heightChanged = true;
+					item.height = item.instance.getVirtualizedHeight();
+				}
+			}
+			currentTop += item.instance.getVirtualizedHeight();
+			if (index < this.items.length - 1) currentTop += this.getViewerMetrics().gap;
+		}
+		if (heightChanged && currentTop != null) {
+			this.scrollDirty = true;
+			this.scrollHeight = currentTop;
+		}
+	}
+	updateStickyPositioning() {
+		const { firstIndex, lastIndex } = this.renderState;
+		const firstStickySpecs = this.items[firstIndex]?.instance.getAdvancedStickySpecs();
+		const lastStickySpecs = this.items[lastIndex]?.instance.getAdvancedStickySpecs();
+		if (firstStickySpecs == null || lastStickySpecs == null) return;
+		const height = this.getHeight();
+		const itemMetrics = this.getItemMetrics();
+		const stickyTop = Math.max(firstStickySpecs.topOffset, 0);
+		const stickyBottom = lastStickySpecs.topOffset + lastStickySpecs.height;
+		const stickyContainerHeight = stickyBottom - stickyTop;
+		if (stickyContainerHeight === this.renderState.stickyHeight && stickyTop === this.renderState.stickyTop && stickyBottom === this.renderState.stickyBottom) return;
+		this.renderState.stickyHeight = stickyContainerHeight;
+		this.renderState.stickyTop = stickyTop;
+		this.renderState.stickyBottom = stickyBottom;
+		this.stickyOffset.style.height = `${stickyTop}px`;
+		const randomOffset = (Math.random() * itemMetrics.lineHeight >> 0) * -1;
+		const stickyJitter = -Math.max(stickyContainerHeight + randomOffset, 0) + height;
+		this.stickyContainer.style.top = `${stickyJitter}px`;
+		this.stickyContainer.style.bottom = `${stickyJitter + itemMetrics.diffHeaderHeight}px`;
+	}
+	handleScroll = () => {
+		if (CodeView.__STOP) return;
+		this.suspendPointerEvents();
+		this.scrollDirty = true;
+		this.notifyScroll();
+		this.render();
+	};
+	clearPendingScroll = () => {
+		this.pendingScrollTarget = void 0;
+		this.pendingLayoutAnchor = void 0;
+		this.scrollAnimation = void 0;
+	};
+	handleResize = (entries) => {
+		for (const entry of entries) if (entry.target === this.stickyContainer) {
+			if (entry.borderBoxSize[0].blockSize !== this.renderState.stickyHeight) {
+				const currentScrollTop = this.getScrollTop();
+				const anchor = this.getScrollAnchor(currentScrollTop);
+				this.reconcileRenderedItems();
+				this.updateStickyPositioning();
+				const anchoredScrollTop = anchor != null ? this.resolveAnchoredScrollTop(anchor) : void 0;
+				if (anchoredScrollTop != null) {
+					const resizeAnchorDelta = anchoredScrollTop - currentScrollTop;
+					this.applyScrollFix(anchoredScrollTop, currentScrollTop);
+					if (this.scrollAnimation != null) this.scrollAnimation.position += resizeAnchorDelta;
+				}
+				if (this.pendingScrollTarget != null && this.isPendingTargetSettled(this.pendingScrollTarget)) {
+					this.pendingScrollTarget = void 0;
+					this.scrollAnimation = void 0;
+				}
+			}
+		} else {
+			this.scrollDirty = true;
+			this.heightDirty = true;
+			this.render();
+		}
+	};
+	/**
+	* Figure out scrollTop accounting for sticky header if enabled and
+	* necessary
+	*/
+	getScrollAnchorViewportTop(absoluteItemTop, scrollTop) {
+		return absoluteItemTop < scrollTop ? scrollTop + this.getStickyHeaderOffset() : scrollTop;
+	}
+	/**
+	* Attempt to find a scroll anchor based on build in metrics of the existing
+	* rendered files/diff.
+	*
+	* A scroll anchor represents the first fully visible element (in other
+	* words, the first file or first line who's top is fully in the viewport).
+	*/
+	getScrollAnchor(scrollTop) {
+		if (this.pendingLayoutAnchor != null) return this.pendingLayoutAnchor;
+		const { firstIndex, lastIndex, stickyTop, stickyBottom } = this.renderState;
+		if (firstIndex === -1 || lastIndex === -1) return;
+		const viewportHeight = this.getHeight();
+		if (stickyTop === -1 || stickyBottom === -1) return;
+		for (let index = firstIndex; index <= lastIndex; index++) {
+			const item = this.items[index];
+			if (item == null) continue;
+			const absoluteItemTop = this.getViewerMetrics().paddingTop + item.top;
+			if (absoluteItemTop + item.height <= scrollTop) continue;
+			if (absoluteItemTop >= scrollTop + viewportHeight) break;
+			if (absoluteItemTop >= scrollTop) return {
+				type: "item",
+				id: item.item.id,
+				viewportOffset: absoluteItemTop - scrollTop
+			};
+			const localViewportTop = this.getScrollAnchorViewportTop(absoluteItemTop, scrollTop) - absoluteItemTop;
+			const lineAnchor = item.instance.getNumericScrollAnchor(localViewportTop);
+			if (lineAnchor != null) {
+				const absoluteLineTop = absoluteItemTop + lineAnchor.top;
+				return {
+					type: "line",
+					id: item.item.id,
+					lineNumber: lineAnchor.lineNumber,
+					side: lineAnchor.side,
+					viewportOffset: absoluteLineTop - scrollTop
+				};
+			}
+		}
+	}
+	/**
+	* Given a scroll anchor, attempt to resolve a newly updated (and clamped)
+	* scroll position to keep the anchored element in place.
+	*
+	* If we can't resolve a position for whatever reason, we'll return
+	* undefined.
+	*/
+	resolveAnchoredScrollTop(anchor) {
+		const item = this.idToItem.get(anchor.id);
+		if (item == null) return;
+		const { paddingTop } = this.getViewerMetrics();
+		if (anchor.type === "item") {
+			const absoluteItemTop = paddingTop + item.top;
+			return this.clampScrollTop(absoluteItemTop - anchor.viewportOffset);
+		}
+		const linePosition = item.type === "diff" ? item.instance.getLinePosition(anchor.lineNumber, anchor.side) : item.instance.getLinePosition(anchor.lineNumber);
+		if (linePosition == null) return;
+		const absoluteLineTop = paddingTop + item.top + linePosition.top;
+		return this.clampScrollTop(absoluteLineTop - anchor.viewportOffset);
+	}
+	/**
+	* Apply a device-pixel-rounded scroll position if it differs from the last
+	* rendered/applied scrollTop we've already recorded in renderState.
+	*/
+	applyScrollFix(target, currentScrollTop) {
+		if (this.root == null) return;
+		const rounded = roundToDevicePixel(this.clampScrollTop(target));
+		const roundedCurrentScrollTop = roundToDevicePixel(currentScrollTop ?? this.scrollTop);
+		if (rounded === this.renderState.scrollTop && rounded === roundedCurrentScrollTop) return;
+		this.suspendPointerEvents();
+		if (rounded !== roundedCurrentScrollTop) this.root.scrollTo({
+			top: rounded,
+			behavior: "instant"
+		});
+		this.renderState.scrollTop = rounded;
+		this.scrollTop = rounded;
+		this.scrollDirty = false;
+	}
+	/**
+	* Decide whether a pending programmatic scroll has reached its
+	* destination and should be cleared.
+	*/
+	isPendingTargetSettled(target) {
+		const top = this.resolveScrollTargetTop(target);
+		if (top == null) return true;
+		return roundToDevicePixel(this.getScrollTop()) === roundToDevicePixel(top);
+	}
+	getScrollTop() {
+		if (!this.scrollDirty) return this.scrollTop;
+		this.scrollDirty = false;
+		this.scrollTop = this.clampScrollTop(this.root?.scrollTop ?? 0);
+		return this.scrollTop;
+	}
+	getHeight() {
+		if (!this.heightDirty) return this.height;
+		this.heightDirty = false;
+		this.height = this.root?.getBoundingClientRect().height ?? 0;
+		return this.height;
+	}
+	getScrollHeight() {
+		return this.scrollHeight;
+	}
+	flushSlotCoordinator() {
+		if (this.slotCoordinator == null) return;
+		const { onSnapshotChange } = this.slotCoordinator;
+		const slotSnapshot = getSlotSnapshot(this.getRenderedItems(), this.slotCoordinator);
+		if (areSlotSnapshotsEqual(this.slotSnapshot, slotSnapshot)) return;
+		this.slotSnapshot = slotSnapshot;
+		onSnapshotChange(slotSnapshot);
+	}
+	notifyScroll() {
+		if (this.scrollListeners.size === 0) return;
+		const scrollTop = this.getScrollTop();
+		for (const listener of this.scrollListeners) listener(scrollTop, this);
+	}
+	/**
+	* Find the first item whose bottom edge crosses into the viewport window.
+	* This lets scroll-time rendering jump directly near the visible range instead
+	* of linearly scanning from the start of very large item lists.
+	*/
+	findFirstVisibleIndex(top) {
+		let low = 0;
+		let high = this.items.length - 1;
+		let result = this.items.length;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			const item = this.items[mid];
+			if (item == null) throw new Error("CodeView.findFirstVisibleIndex: invalid item index");
+			if (item.top + item.height > top) {
+				result = mid;
+				high = mid - 1;
+			} else low = mid + 1;
+		}
+		return result;
+	}
+	/**
+	* Find the last item whose top edge is still within the viewport window.
+	* Paired with findFirstVisibleIndex, this bounds the render loop to only the
+	* slice of items that can actually intersect the current scroll range.
+	*/
+	findLastVisibleIndex(bottom) {
+		let low = 0;
+		let high = this.items.length - 1;
+		let result = -1;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			const item = this.items[mid];
+			if (item == null) throw new Error("CodeView.findLastVisibleIndex: invalid item index");
+			if (item.top <= bottom) {
+				result = mid;
+				low = mid + 1;
+			} else high = mid - 1;
+		}
+		return result;
+	}
+	/**
+	* Recompute measured tops and heights starting from the earliest dirty item.
+	* Earlier items keep their existing layout, while everything from startIndex
+	* onward is remeasured so downstream positions and total scroll height stay
+	* consistent after inserts, removals, or versioned item updates.
+	*/
+	recomputeLayout(startIndex = 0) {
+		if (this.items.length === 0) {
+			this.scrollHeight = 0;
+			return;
+		}
+		const viewerMetrics = this.getViewerMetrics();
+		let runningTop = 0;
+		if (startIndex > 0) {
+			const previousItem = this.items[startIndex - 1];
+			if (previousItem == null) throw new Error("CodeView.recomputeLayout: invalid dirty index");
+			runningTop = previousItem.top + previousItem.height + viewerMetrics.gap;
+		}
+		for (let index = startIndex; index < this.items.length; index++) {
+			const item = this.items[index];
+			if (item == null) throw new Error("CodeView.recomputeLayout: invalid item index");
+			item.top = runningTop;
+			if (item.type === "diff") item.height = item.instance.prepareVirtualizedItem(item.item.fileDiff);
+			else item.height = item.instance.prepareVirtualizedItem(item.item.file);
+			runningTop += item.height;
+			if (index < this.items.length - 1) runningTop += viewerMetrics.gap;
+		}
+		if (runningTop !== this.scrollHeight) this.scrollDirty = true;
+		this.scrollHeight = runningTop;
+	}
+	resetRenderState() {
+		this.renderState.scrollTop = -1;
+		this.renderState.firstIndex = -1;
+		this.renderState.lastIndex = -1;
+		this.renderState.stickyHeight = 0;
+		this.renderState.stickyTop = -1;
+		this.renderState.stickyBottom = -1;
+	}
+	getFitPerfectlyOverscroll() {
+		return this.getViewerMetrics().gap + this.getItemMetrics().diffHeaderHeight;
+	}
+};
+function cleanRenderedItem(item) {
+	item.instance.cleanUp(true);
+	item.element?.remove();
+	item.element = void 0;
+}
+function prepareItemInstance(item) {
+	item.instance.cleanUp(true);
+	if (item.type === "diff") return item.instance.prepareVirtualizedItem(item.item.fileDiff);
+	else return item.instance.prepareVirtualizedItem(item.item.file);
+}
+function renderItem(item, fileContainer) {
+	if (item.type === "diff") return item.instance.render({
+		deferManagers: true,
+		fileContainer,
+		fileDiff: item.item.fileDiff,
+		lineAnnotations: item.item.annotations
+	});
+	else return item.instance.render({
+		deferManagers: true,
+		fileContainer,
+		file: item.item.file,
+		lineAnnotations: item.item.annotations
+	});
+}
+/**
+* Keep the rendered DOM order aligned with the current record order even when
+* we reuse existing elements. Reused items may already be mounted elsewhere in
+* the sticky container, so this moves them into the correct sibling position
+* before rendering updates.
+*/
+function syncRenderedItemOrder(container, element, prevElement) {
+	if (prevElement == null) {
+		if (container.firstChild !== element) container.prepend(element);
+		return;
+	}
+	if (prevElement.nextSibling !== element) prevElement.after(element);
+}
+function hasAnnotations(item) {
+	return (item.annotations?.length ?? 0) > 0;
+}
+function getSlotSnapshot(renderedItems, { hasHeaderRenderers, hasAnnotationRenderer, hasGutterRenderer }) {
+	if (renderedItems.length === 0) return;
+	if (hasHeaderRenderers || hasGutterRenderer) return renderedItems;
+	if (!hasAnnotationRenderer) return;
+	const slotSnapshot = [];
+	for (const renderedItem of renderedItems) if (hasAnnotations(renderedItem.item)) slotSnapshot.push(renderedItem);
+	return slotSnapshot.length > 0 ? slotSnapshot : void 0;
+}
+function areSlotSnapshotsEqual(previous, next) {
+	if (previous == null || next == null) return previous === next;
+	if (previous.length !== next.length) return false;
+	for (let index = 0; index < previous.length; index++) {
+		const previousItem = previous[index];
+		const nextItem = next[index];
+		if (previousItem == null || nextItem == null || previousItem.id !== nextItem.id || previousItem.type !== nextItem.type || previousItem.element !== nextItem.element || previousItem.version !== nextItem.version) return false;
+	}
+	return true;
+}
+
+//#endregion
+export { CodeView };
+//# sourceMappingURL=CodeView.js.map