@pierre/diffs 1.2.0-beta.1 → 1.2.0-beta.3

package/dist/components/CodeView.js

@@ -81,6 +81,11 @@ const CODE_VIEW_SELECTION_CALLBACK_KEYS = [
 	"onLineSelectionEnd"
 ];
 const DEFAULT_POINTER_EVENTS_RESTORE_DELAY_MS = 120;
+const SCROLL_REBASE_CONTAINER_HEIGHT = 12e6;
+const SCROLL_REBASE_TRIGGER_TOP = 1e6;
+const SCROLL_REBASE_TARGET_TOP = 2e6;
+const SCROLL_REBASE_TARGET_BOTTOM = SCROLL_REBASE_CONTAINER_HEIGHT - SCROLL_REBASE_TARGET_TOP;
+const SCROLL_REBASE_THRESHOLD = SCROLL_REBASE_CONTAINER_HEIGHT - SCROLL_REBASE_TRIGGER_TOP;
 var CodeView = class CodeView {
 	static __STOP = false;
 	static __lastScrollPosition = 0;
@@ -101,6 +106,7 @@ var CodeView = class CodeView {
 	scrollHeight = 0;
 	containerHeight = -1;
 	scrollTop = 0;
+	scrollPageOffset = 0;
 	scrollDirty = true;
 	pointerEventsRestoreTimer;
 	pointerEventsDisabled = false;
@@ -185,7 +191,7 @@ var CodeView = class CodeView {
 		this.root = root;
 		this.root.style.overflowAnchor = "none";
 		this.container ??= document.createElement("div");
-		this.container.style.contain = "layout size style";
+		this.container.style.contain = "layout style";
 		this.syncViewerMetrics();
 		this.container.appendChild(this.stickyOffset);
 		this.container.appendChild(this.stickyContainer);
@@ -227,6 +233,7 @@ var CodeView = class CodeView {
 		this.stickyContainer.textContent = "";
 		this.stickyOffset.style.height = "";
 		this.container?.style.removeProperty("height");
+		this.containerHeight = -1;
 		this.windowSpecs = {
 			top: 0,
 			bottom: 0
@@ -234,6 +241,7 @@ var CodeView = class CodeView {
 		this.pendingLayoutAnchor = void 0;
 		this.height = 0;
 		this.scrollTop = 0;
+		this.scrollPageOffset = 0;
 		this.scrollHeight = 0;
 		this.scrollDirty = true;
 		this.heightDirty = true;
@@ -296,6 +304,22 @@ var CodeView = class CodeView {
 	clearSelectedLines(options) {
 		this.applySelectedLines(null, options);
 	}
+	getItem(itemId) {
+		return this.idToItem.get(itemId)?.item;
+	}
+	updateItem(input) {
+		const item = this.idToItem.get(input.id);
+		if (item == null) {
+			console.error(`CodeView.updateItem: unknown item id "${input.id}"`);
+			return false;
+		}
+		if (!this.syncItemRecord(item, input)) return false;
+		this.markItemLayoutDirty(item);
+		this.scrollDirty = true;
+		this.render();
+		this.syncSelection();
+		return true;
+	}
 	addItem(input) {
 		this.addItems([input]);
 		this.syncSelection();
@@ -320,6 +344,7 @@ var CodeView = class CodeView {
 		if (inputs.length === 0) return;
 		const viewerMetrics = this.getViewerMetrics();
 		let nextTop = this.items.length === 0 ? 0 : this.scrollHeight + viewerMetrics.gap;
+		const appendedTop = nextTop;
 		for (let index = 0; index < inputs.length; index++) {
 			const input = inputs[index];
 			if (input == null) throw new Error("CodeView.appendItemsInternal: missing input item");
@@ -333,7 +358,11 @@ var CodeView = class CodeView {
 		}
 		this.scrollHeight = nextTop - viewerMetrics.gap;
 		this.scrollDirty = true;
-		if (render) this.render();
+		if (render) if (this.canSkipRenderForAppend(appendedTop)) this.syncContainerHeight();
+		else this.render();
+	}
+	canSkipRenderForAppend(appendedTop) {
+		return this.container != null && this.renderState.firstIndex !== -1 && this.pendingScrollTarget == null && this.scrollAnimation == null && this.layoutDirtyIndex == null && appendedTop > this.windowSpecs.bottom;
 	}
 	setOptions(options) {
 		if (options == null) return;
@@ -419,15 +448,15 @@ var CodeView = class CodeView {
 			this.scrollListeners.delete(listener);
 		};
 	}
-	getTopForInstance(instance) {
+	getLocalTopForInstance(instance) {
 		const item = this.instanceToItem.get(instance);
-		if (item == null) throw new Error("CodeView.getTopForInstance: unknown virtualized instance");
+		if (item == null) throw new Error("CodeView.getLocalTopForInstance: unknown virtualized instance");
 		return item.top;
 	}
 	getTopForItem(id) {
 		const item = this.idToItem.get(id);
 		if (item == null) return;
-		return item.top;
+		return item.top + this.getViewerMetrics().paddingTop;
 	}
 	createItem(input, index, top) {
 		const itemMetrics = this.getItemMetrics();
@@ -638,15 +667,81 @@ var CodeView = class CodeView {
 		else item.instance.setOptions(this.createOptions(item.item));
 		return true;
 	}
+	getMaxScrollTopForHeight(scrollHeight) {
+		const { paddingBottom, paddingTop } = this.getViewerMetrics();
+		return Math.max(paddingTop + scrollHeight + paddingBottom - this.getHeight(), 0);
+	}
+	getMaxScrollTop() {
+		return this.getMaxScrollTopForHeight(this.getScrollHeight());
+	}
+	shouldRebaseScroll() {
+		return this.getMaxScrollTop() > SCROLL_REBASE_THRESHOLD;
+	}
+	getPagedScrollHeight() {
+		return this.shouldRebaseScroll() ? Math.min(this.getScrollHeight(), SCROLL_REBASE_CONTAINER_HEIGHT) : this.getScrollHeight();
+	}
+	getMaxPagedScrollTop() {
+		return this.getMaxScrollTopForHeight(this.getPagedScrollHeight());
+	}
+	clampPagedScrollTop(value) {
+		const maxScroll = this.getMaxPagedScrollTop();
+		return Math.max(0, Math.min(value, maxScroll));
+	}
 	/**
-	* Clamps a scroll position to the min/max allowable scroll range based on
-	* the computed total height
+	* Clamps a logical scroll position to the min/max allowable scroll range
+	* based on the full computed content height.
 	*/
 	clampScrollTop(value) {
-		const { paddingBottom, paddingTop } = this.getViewerMetrics();
-		const maxScroll = Math.max(paddingTop + this.getScrollHeight() + paddingBottom - this.getHeight(), 0);
+		const maxScroll = this.getMaxScrollTop();
 		return Math.max(0, Math.min(value, maxScroll));
 	}
+	getMaxScrollPageOffset() {
+		return Math.max(this.getMaxScrollTop() - this.getMaxPagedScrollTop(), 0);
+	}
+	clampScrollPageOffset(value) {
+		const maxOffset = this.getMaxScrollPageOffset();
+		return Math.max(0, Math.min(value, maxOffset));
+	}
+	resolveScrollPageWindow(scrollTop, preferredPagedScrollTop) {
+		let pagedScrollTop = roundToDevicePixel(this.clampPagedScrollTop(preferredPagedScrollTop));
+		let scrollPageOffset = this.clampScrollPageOffset(scrollTop - pagedScrollTop);
+		pagedScrollTop = roundToDevicePixel(this.clampPagedScrollTop(scrollTop - scrollPageOffset));
+		scrollPageOffset = this.clampScrollPageOffset(scrollTop - pagedScrollTop);
+		return {
+			pagedScrollTop,
+			scrollPageOffset
+		};
+	}
+	/**
+	* Resolve how a logical scrollTop maps onto the reusable paged scroll window
+	* without mutating the current page offset.
+	*/
+	resolvePagedScrollPosition(logicalScrollTop) {
+		if (!this.shouldRebaseScroll()) return {
+			pagedScrollTop: this.clampPagedScrollTop(logicalScrollTop),
+			scrollPageOffset: 0
+		};
+		const currentPageOffset = this.clampScrollPageOffset(this.scrollPageOffset);
+		const pagedScrollTop = logicalScrollTop - currentPageOffset;
+		const pagedMaxScrollTop = this.getMaxPagedScrollTop();
+		const maxRebaseOffset = this.getMaxScrollPageOffset();
+		const shouldMoveDown = pagedScrollTop > SCROLL_REBASE_THRESHOLD && currentPageOffset < maxRebaseOffset;
+		const shouldMoveUp = pagedScrollTop < SCROLL_REBASE_TRIGGER_TOP && currentPageOffset > 0;
+		if (pagedScrollTop < 0 || pagedScrollTop > pagedMaxScrollTop || shouldMoveDown || shouldMoveUp) return this.resolveScrollPageWindow(logicalScrollTop, shouldMoveUp ? Math.min(SCROLL_REBASE_TARGET_BOTTOM, pagedMaxScrollTop) : SCROLL_REBASE_TARGET_TOP);
+		return {
+			pagedScrollTop: roundToDevicePixel(this.clampPagedScrollTop(pagedScrollTop)),
+			scrollPageOffset: currentPageOffset
+		};
+	}
+	needsScrollPageUpdate(logicalScrollTop) {
+		const roundedScrollTop = roundToDevicePixel(this.clampScrollTop(logicalScrollTop));
+		const { scrollPageOffset } = this.resolvePagedScrollPosition(roundedScrollTop);
+		return scrollPageOffset !== this.scrollPageOffset;
+	}
+	getPagedLayoutTop(logicalTop) {
+		if (!this.shouldRebaseScroll()) return logicalTop;
+		return Math.max(logicalTop - this.scrollPageOffset, 0);
+	}
 	getStickyHeaderOffset() {
 		return this.options.stickyHeaders === true && this.options.disableFileHeader !== true ? this.getItemMetrics().diffHeaderHeight : 0;
 	}
@@ -739,7 +834,7 @@ var CodeView = class CodeView {
 	* smooth scroll animation or not. If not just return the destination, or
 	* compute next position given the smooth scroll spring physics
 	*/
-	computeFrameScrollTop(scrollTop, frameTimestamp) {
+	computeTargetScrollTopForFrame(scrollTop, frameTimestamp) {
 		if (this.pendingScrollTarget == null) return scrollTop;
 		const destination = this.resolveScrollTargetTop(this.pendingScrollTarget);
 		if (destination == null) return scrollTop;
@@ -798,51 +893,50 @@ var CodeView = class CodeView {
 	}
 	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);
+		const viewportHeight = this.getHeight();
+		const initialScrollTop = this.getScrollTop();
+		let scrollTopAfterLayout = initialScrollTop;
+		let computeScrollCorrection = this.pendingLayoutAnchor != null;
+		let scrollAnchor = this.getScrollAnchor(scrollTopAfterLayout);
 		if (this.layoutDirtyIndex != null) {
 			this.recomputeLayout(this.layoutDirtyIndex);
 			this.layoutDirtyIndex = void 0;
-			recomputeScrollTop = true;
+			computeScrollCorrection = 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 (computeScrollCorrection && scrollAnchor != null) {
+			const anchoredScrollTopAfterLayout = this.resolveAnchoredScrollTop(scrollAnchor);
+			if (anchoredScrollTopAfterLayout != null) {
+				const layoutAnchorDelta = anchoredScrollTopAfterLayout - scrollTopAfterLayout;
+				scrollTopAfterLayout = anchoredScrollTopAfterLayout;
+				if (this.scrollAnimation != null) this.scrollAnimation.position += layoutAnchorDelta;
 			}
 		}
-		if (recomputeScrollTop) {
-			currentScrollTop = this.clampScrollTop(currentScrollTop);
+		if (computeScrollCorrection) {
+			scrollTopAfterLayout = this.clampScrollTop(scrollTopAfterLayout);
 			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;
+		const targetScrollTop = this.computeTargetScrollTopForFrame(scrollTopAfterLayout, timestamp);
+		const fitPerfectly = !computeScrollCorrection && (this.renderState.scrollTop === -1 || Math.abs(targetScrollTop - this.renderState.scrollTop) > viewportHeight + this.config.overscrollSize * 2);
+		if (fitPerfectly) scrollAnchor = void 0;
 		this.windowSpecs = createWindowFromScrollPosition({
-			scrollTop: frameScrollTop,
-			height,
+			scrollTop: targetScrollTop,
+			height: viewportHeight,
 			scrollHeight: this.getScrollHeight(),
 			fitPerfectly,
 			fitPerfectlyOverscroll: this.getFitPerfectlyOverscroll(),
 			overscrollSize: this.config.overscrollSize
 		});
+		let syncedScrollTop = initialScrollTop;
+		if (this.pendingScrollTarget != null && targetScrollTop !== syncedScrollTop || this.needsScrollPageUpdate(targetScrollTop)) {
+			this.applyScrollFix(targetScrollTop, syncedScrollTop, this.windowSpecs);
+			syncedScrollTop = targetScrollTop;
+		}
 		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);
+			if (!(item.top > top - item.height && item.top <= bottom)) cleanRenderedItem(item);
 		}
 		let prevElement;
 		const updatedItems = /* @__PURE__ */ new Set();
@@ -870,25 +964,27 @@ var CodeView = class CodeView {
 		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;
+		const anchoredScrollTopAfterRender = scrollAnchor != null ? this.resolveAnchoredScrollTop(scrollAnchor) : void 0;
+		if (scrollAnchor === this.pendingLayoutAnchor) this.pendingLayoutAnchor = void 0;
+		const postRenderAnchorDelta = anchoredScrollTopAfterRender != null ? anchoredScrollTopAfterRender - scrollTopAfterLayout : 0;
+		let postRenderScrollTop = targetScrollTop;
+		let shouldCheckPendingTargetSettled = false;
+		if (this.pendingScrollTarget != null) {
+			const pendingTargetScrollTop = this.advanceScrollAnimation(timestamp, postRenderAnchorDelta);
+			if (pendingTargetScrollTop != null) {
+				postRenderScrollTop = pendingTargetScrollTop;
+				shouldCheckPendingTargetSettled = true;
+			} else postRenderScrollTop = scrollTopAfterLayout;
+		} else postRenderScrollTop = anchoredScrollTopAfterRender ?? targetScrollTop;
+		if (postRenderScrollTop !== syncedScrollTop) {
+			this.applyScrollFix(postRenderScrollTop, syncedScrollTop, this.windowSpecs);
+			syncedScrollTop = postRenderScrollTop;
+		}
+		if (shouldCheckPendingTargetSettled && this.pendingScrollTarget != null && this.isPendingTargetSettled(this.pendingScrollTarget)) {
+			this.pendingScrollTarget = void 0;
+			this.scrollAnimation = void 0;
 		}
-		this.renderState.scrollTop = roundToDevicePixel(renderedScrollTop);
+		this.renderState.scrollTop = roundToDevicePixel(syncedScrollTop);
 		this.flushManagers(updatedItems);
 		if (fitPerfectly || this.scrollAnimation != null) this.render();
 	};
@@ -896,10 +992,43 @@ var CodeView = class CodeView {
 		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;
+		const pagedScrollHeight = this.getPagedScrollHeight();
+		if (this.container == null || this.containerHeight === pagedScrollHeight) return;
+		this.container.style.height = `${pagedScrollHeight}px`;
+		this.containerHeight = pagedScrollHeight;
+	}
+	getStickyBounds(windowSpecs) {
+		const { firstIndex, lastIndex } = windowSpecs != null ? {
+			firstIndex: this.findFirstVisibleIndex(windowSpecs.top),
+			lastIndex: this.findLastVisibleIndex(windowSpecs.bottom)
+		} : this.renderState;
+		if (firstIndex === -1 || lastIndex === -1 || firstIndex > lastIndex) return;
+		const firstStickySpecs = this.items[firstIndex]?.instance.getAdvancedStickySpecs(windowSpecs);
+		const lastStickySpecs = this.items[lastIndex]?.instance.getAdvancedStickySpecs(windowSpecs);
+		if (firstStickySpecs == null || lastStickySpecs == null) return;
+		return {
+			stickyTop: this.getPagedLayoutTop(Math.max(firstStickySpecs.topOffset, 0)),
+			stickyBottom: this.getPagedLayoutTop(lastStickySpecs.topOffset + lastStickySpecs.height)
+		};
+	}
+	applyStickyPositioning({ stickyTop, stickyBottom }) {
+		const height = this.getHeight();
+		const itemMetrics = this.getItemMetrics();
+		const stickyContainerHeight = stickyBottom - stickyTop;
+		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`;
+	}
+	syncPagedScrollScaffolding(windowSpecs) {
+		this.syncContainerHeight();
+		const stickyBounds = this.getStickyBounds(windowSpecs);
+		if (stickyBounds == null) return;
+		this.applyStickyPositioning(stickyBounds);
 	}
 	reconcileRenderedItems(updatedItems) {
 		const { firstIndex, lastIndex } = this.renderState;
@@ -931,24 +1060,11 @@ var CodeView = class CodeView {
 		}
 	}
 	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`;
+		const stickyBounds = this.getStickyBounds();
+		if (stickyBounds == null) return;
+		const { stickyTop, stickyBottom } = stickyBounds;
+		if (stickyBottom - stickyTop === this.renderState.stickyHeight && stickyTop === this.renderState.stickyTop && stickyBottom === this.renderState.stickyBottom) return;
+		this.applyStickyPositioning(stickyBounds);
 	}
 	handleScroll = () => {
 		if (CodeView.__STOP) return;
@@ -972,7 +1088,7 @@ var CodeView = class CodeView {
 				const anchoredScrollTop = anchor != null ? this.resolveAnchoredScrollTop(anchor) : void 0;
 				if (anchoredScrollTop != null) {
 					const resizeAnchorDelta = anchoredScrollTop - currentScrollTop;
-					this.applyScrollFix(anchoredScrollTop, currentScrollTop);
+					this.applyScrollFix(anchoredScrollTop, currentScrollTop, this.windowSpecs);
 					if (this.scrollAnimation != null) this.scrollAnimation.position += resizeAnchorDelta;
 				}
 				if (this.pendingScrollTarget != null && this.isPendingTargetSettled(this.pendingScrollTarget)) {
@@ -1053,20 +1169,29 @@ var CodeView = class CodeView {
 	}
 	/**
 	* Apply a device-pixel-rounded scroll position if it differs from the last
-	* rendered/applied scrollTop we've already recorded in renderState.
+	* logical scrollTop synchronized into the paged scroll scaffold.
 	*/
-	applyScrollFix(target, currentScrollTop) {
+	applyScrollFix(targetScrollTop, syncedScrollTop, windowSpecs) {
 		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;
+		const roundedTargetScrollTop = roundToDevicePixel(this.clampScrollTop(targetScrollTop));
+		const roundedSyncedScrollTop = roundToDevicePixel(syncedScrollTop);
+		const { scrollPageOffset: previousPageOffset } = this;
+		const syncedPagedScrollTop = roundToDevicePixel(this.clampPagedScrollTop(roundedSyncedScrollTop - previousPageOffset));
+		const { pagedScrollTop, scrollPageOffset } = this.resolvePagedScrollPosition(roundedTargetScrollTop);
+		const targetPagedScrollTop = pagedScrollTop;
+		const rebaseChanged = previousPageOffset !== scrollPageOffset;
+		if (roundedTargetScrollTop === this.renderState.scrollTop && roundedTargetScrollTop === roundedSyncedScrollTop && targetPagedScrollTop === syncedPagedScrollTop && !rebaseChanged) return;
 		this.suspendPointerEvents();
-		if (rounded !== roundedCurrentScrollTop) this.root.scrollTo({
-			top: rounded,
+		if (targetPagedScrollTop !== syncedPagedScrollTop || rebaseChanged) {
+			this.scrollPageOffset = scrollPageOffset;
+			this.syncPagedScrollScaffolding(windowSpecs);
+		}
+		if (targetPagedScrollTop !== syncedPagedScrollTop) this.root.scrollTo({
+			top: targetPagedScrollTop,
 			behavior: "instant"
 		});
-		this.renderState.scrollTop = rounded;
-		this.scrollTop = rounded;
+		this.renderState.scrollTop = roundedTargetScrollTop;
+		this.scrollTop = roundedTargetScrollTop;
 		this.scrollDirty = false;
 	}
 	/**
@@ -1081,7 +1206,8 @@ var CodeView = class CodeView {
 	getScrollTop() {
 		if (!this.scrollDirty) return this.scrollTop;
 		this.scrollDirty = false;
-		this.scrollTop = this.clampScrollTop(this.root?.scrollTop ?? 0);
+		const rootScrollTop = this.root?.scrollTop ?? 0;
+		this.scrollTop = this.clampScrollTop(rootScrollTop + this.scrollPageOffset);
 		return this.scrollTop;
 	}
 	getHeight() {