@stream-mdx/react 0.5.0 → 1.0.0

package/dist/renderer/virtualized-code.d.ts

@@ -1,43 +1,44 @@
-import React from 'react';
-import { TokenLineV1 } from '@stream-mdx/core';
+import React__default from 'react';
 
 interface VirtualizedCodeConfig {
     enabled: boolean;
     windowSize: number;
     bufferSize: number;
     virtualizeThreshold: number;
+    followTail?: boolean;
 }
 declare const DEFAULT_VIRTUALIZED_CODE_CONFIG: VirtualizedCodeConfig;
-interface VirtualizedLine {
-    id: string;
-    index: number;
-    text: string;
-    html?: string | null;
-    tokens?: TokenLineV1 | null;
-}
-interface VirtualizedCodeWindow {
+declare function resolveVirtualizedCodeConfig(options?: Partial<VirtualizedCodeConfig>): VirtualizedCodeConfig;
+interface VirtualizedCodeRange {
     startIndex: number;
     endIndex: number;
     visibleStart: number;
     visibleEnd: number;
-    visibleLines: VirtualizedLine[];
     totalLines: number;
     mountedLines: number;
 }
-/**
- * Calculate which lines should be rendered based on scroll position
- */
-declare function calculateCodeWindow(lines: ReadonlyArray<VirtualizedLine>, scrollTop: number, containerHeight: number, lineHeight: number, config: VirtualizedCodeConfig): VirtualizedCodeWindow;
-/**
- * Hook for virtualized code block scrolling
- */
-declare function useVirtualizedCode(lines: ReadonlyArray<VirtualizedLine>, config?: VirtualizedCodeConfig): {
-    containerRef: React.MutableRefObject<HTMLDivElement | null>;
-    window: VirtualizedCodeWindow;
-    handleScroll: (e: React.UIEvent<HTMLDivElement>) => void;
+declare function calculateCodeWindow(totalLines: number, scrollTop: number, containerHeight: number, lineHeight: number, config: VirtualizedCodeConfig): VirtualizedCodeRange;
+interface CodeViewportRenderRange {
+    startIndex: number;
+    endIndex: number;
+    visibleStart: number;
+    visibleEnd: number;
+    spacerBeforeHeight: number;
+}
+/** Owns viewport geometry and scroll position only; record ranges subscribe separately. */
+declare function useVirtualizedCode(totalLines: number, generation: number, config?: VirtualizedCodeConfig, ownerId?: string, configurationRevision?: number, ownerIdentity?: object): {
+    containerRef: React__default.MutableRefObject<HTMLDivElement | null>;
+    isPrinting: boolean;
+    selectionLineIndices: readonly number[];
+    window: VirtualizedCodeRange;
+    renderRanges: readonly CodeViewportRenderRange[];
+    mountedLineCount: number;
+    spacerTopHeight: number;
+    spacerBottomHeight: number;
+    handleScroll: (event: React__default.UIEvent<HTMLDivElement>) => void;
     scrollToLine: (lineIndex: number) => void;
     lineHeight: number;
     config: VirtualizedCodeConfig;
 };
 
-export { DEFAULT_VIRTUALIZED_CODE_CONFIG, type VirtualizedCodeConfig, type VirtualizedCodeWindow, type VirtualizedLine, calculateCodeWindow, useVirtualizedCode };
+export { DEFAULT_VIRTUALIZED_CODE_CONFIG, type VirtualizedCodeConfig, type VirtualizedCodeRange, calculateCodeWindow, resolveVirtualizedCodeConfig, useVirtualizedCode };

package/dist/renderer/virtualized-code.mjs

@@ -2,98 +2,445 @@
 
 // src/renderer/virtualized-code.tsx
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { flushSync } from "react-dom";
+
+// src/renderer/viewport-height-index.ts
+var ViewportHeightIndex = class {
+  constructor() {
+    this.count = 0;
+    this.estimate = 20;
+    this.measuredHeights = /* @__PURE__ */ new Map();
+    this.heightDeltas = /* @__PURE__ */ new Map();
+  }
+  reset(count, estimate) {
+    this.count = Number.isFinite(count) ? Math.max(0, Math.floor(count)) : 0, this.estimate = Number.isFinite(estimate) && estimate > 0 ? estimate : 20, this.measuredHeights.clear(), this.heightDeltas.clear();
+  }
+  resize(count) {
+    let nextCount = Number.isFinite(count) ? Math.max(0, Math.floor(count)) : 0;
+    if (nextCount !== this.count) {
+      if (nextCount < this.count) {
+        for (let index = nextCount; index < this.count; index += 1)
+          this.measuredHeights.delete(index), this.heightDeltas.delete(index + 1);
+        this.count = nextCount;
+        return;
+      }
+      for (let index = this.count + 1; index <= nextCount; index += 1) {
+        let start = index - (index & -index), delta = this.prefix(index - 1) - this.prefix(start);
+        delta !== 0 && this.heightDeltas.set(index, delta);
+      }
+      this.count = nextCount;
+    }
+  }
+  setHeight(index, height) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= this.count || !Number.isFinite(height) || height <= 0)
+      return !1;
+    let previous = this.measuredHeights.get(index) ?? this.estimate;
+    return Math.abs(previous - height) <= 0.5 ? !1 : (this.measuredHeights.set(index, height), this.add(index + 1, height - previous), !0);
+  }
+  offsetAt(index) {
+    let end = Number.isFinite(index) ? Math.max(0, Math.min(this.count, Math.floor(index))) : 0;
+    return end * this.estimate + this.prefix(end);
+  }
+  indexAt(offset) {
+    if (this.count === 0) return 0;
+    let target = Number.isNaN(offset) ? 0 : Math.max(0, Math.min(offset, this.offsetAt(this.count))), index = 0, delta = 0, bit = 1;
+    for (; bit <= Math.floor(this.count / 2); ) bit *= 2;
+    for (; bit > 0; ) {
+      let next = index + bit;
+      if (next <= this.count) {
+        let nextDelta = delta + (this.heightDeltas.get(next) ?? 0);
+        next * this.estimate + nextDelta <= target && (index = next, delta = nextDelta);
+      }
+      bit = Math.floor(bit / 2);
+    }
+    return index;
+  }
+  prefix(count) {
+    let total = 0;
+    for (let index = count; index > 0; index -= index & -index) total += this.heightDeltas.get(index) ?? 0;
+    return total;
+  }
+  add(index, delta) {
+    for (let cursor = index; cursor <= this.count; cursor += cursor & -cursor) {
+      let next = (this.heightDeltas.get(cursor) ?? 0) + delta;
+      next === 0 ? this.heightDeltas.delete(cursor) : this.heightDeltas.set(cursor, next);
+    }
+  }
+};
+
+// src/renderer/virtualized-code.tsx
 var DEFAULT_VIRTUALIZED_CODE_CONFIG = {
-  enabled: true,
+  enabled: !0,
   windowSize: 100,
-  // Render 100 lines at a time
   bufferSize: 50,
-  // +50 lines buffer above/below
-  virtualizeThreshold: 200
-  // Only virtualize if 200+ lines
+  virtualizeThreshold: 200,
+  followTail: !1
 };
-function calculateCodeWindow(lines, scrollTop, containerHeight, lineHeight, config) {
-  const totalLines = lines.length;
-  if (!config.enabled || totalLines < config.virtualizeThreshold) {
+function resolveVirtualizedCodeConfig(options) {
+  return {
+    ...DEFAULT_VIRTUALIZED_CODE_CONFIG,
+    ...options,
+    followTail: options?.followTail ?? DEFAULT_VIRTUALIZED_CODE_CONFIG.followTail
+  };
+}
+var DEFAULT_CODE_LINE_HEIGHT = 20, CODE_FOLLOW_TAIL_EPS_BOTTOM_PX = 2, CODE_FOLLOW_TAIL_DETACH_SCROLL_DELTA_PX = 1, DEFAULT_CODE_VIEWPORT_OWNER = {};
+function calculateCodeWindow(totalLines, scrollTop, containerHeight, lineHeight, config) {
+  let lineCount = Math.max(0, totalLines);
+  if (!config.enabled || lineCount < config.virtualizeThreshold)
     return {
       startIndex: 0,
-      endIndex: totalLines,
+      endIndex: lineCount,
       visibleStart: 0,
-      visibleEnd: totalLines,
-      visibleLines: lines,
-      totalLines,
-      mountedLines: totalLines
+      visibleEnd: lineCount,
+      totalLines: lineCount,
+      mountedLines: lineCount
     };
-  }
-  const firstVisibleLine = Math.floor(scrollTop / lineHeight);
-  const lastVisibleLine = Math.ceil((scrollTop + containerHeight) / lineHeight);
-  const visibleStart = Math.max(0, firstVisibleLine);
-  const visibleEnd = Math.min(totalLines, Math.max(visibleStart, lastVisibleLine));
-  const startIndex = Math.max(0, visibleStart - config.bufferSize);
-  const endIndex = Math.min(totalLines, visibleEnd + config.bufferSize);
+  let measuredLineHeight = lineHeight > 0 ? lineHeight : 20, firstVisibleLine = Math.floor(Math.max(0, scrollTop) / measuredLineHeight), visibleLineCount = containerHeight > 0 ? Math.max(1, Math.ceil(containerHeight / measuredLineHeight)) : Math.max(1, config.windowSize), visibleStart = Math.min(lineCount, firstVisibleLine), visibleEnd = Math.min(lineCount, visibleStart + visibleLineCount), bufferSize = Math.max(0, config.bufferSize), startIndex = Math.max(0, visibleStart - bufferSize), endIndex = Math.min(lineCount, visibleEnd + bufferSize);
   return {
     startIndex,
     endIndex,
     visibleStart,
     visibleEnd,
-    visibleLines: lines.slice(startIndex, endIndex),
-    totalLines,
+    totalLines: lineCount,
     mountedLines: endIndex - startIndex
   };
 }
-function useVirtualizedCode(lines, config = DEFAULT_VIRTUALIZED_CODE_CONFIG) {
-  const containerRef = useRef(null);
-  const [scrollTop, setScrollTop] = useState(0);
-  const [containerHeight, setContainerHeight] = useState(0);
-  const lineHeightRef = useRef(20);
+var EMPTY_SELECTION_LINE_INDICES = [];
+function calculateMeasuredCodeWindow(totalLines, scrollTop, containerHeight, heights, config) {
+  let lineCount = Math.max(0, totalLines);
+  if (!config.enabled || lineCount < config.virtualizeThreshold)
+    return {
+      window: calculateCodeWindow(lineCount, scrollTop, containerHeight, DEFAULT_CODE_LINE_HEIGHT, config),
+      spacerTopHeight: 0,
+      spacerBottomHeight: 0
+    };
+  let totalHeight = heights.offsetAt(lineCount), viewportHeight = containerHeight > 0 ? containerHeight : Math.max(1, config.windowSize) * DEFAULT_CODE_LINE_HEIGHT, top = Math.min(
+    Math.max(0, scrollTop),
+    Math.max(0, totalHeight - viewportHeight)
+  ), bottom = top + viewportHeight, visibleStart = Math.min(lineCount, heights.indexAt(top)), visibleEnd = heights.indexAt(bottom);
+  visibleEnd < lineCount && heights.offsetAt(visibleEnd) < bottom && (visibleEnd += 1), visibleEnd = Math.min(lineCount, Math.max(visibleStart, visibleEnd));
+  let bufferSize = Math.max(0, config.bufferSize), startIndex = Math.max(0, visibleStart - bufferSize), endIndex = Math.min(lineCount, visibleEnd + bufferSize);
+  return {
+    window: {
+      startIndex,
+      endIndex,
+      visibleStart,
+      visibleEnd,
+      totalLines: lineCount,
+      mountedLines: endIndex - startIndex
+    },
+    spacerTopHeight: heights.offsetAt(startIndex),
+    spacerBottomHeight: Math.max(0, totalHeight - heights.offsetAt(endIndex))
+  };
+}
+function useVirtualizedCode(totalLines, generation, config = DEFAULT_VIRTUALIZED_CODE_CONFIG, ownerId = "", configurationRevision = 0, ownerIdentity = DEFAULT_CODE_VIEWPORT_OWNER) {
+  let containerRef = useRef(null), [scrollTop, setScrollTop] = useState(0), [containerHeight, setContainerHeight] = useState(0), [containerWidth, setContainerWidth] = useState(0), [measureVersion, setMeasureVersion] = useState(0), [selectionState, setSelectionState] = useState(() => ({
+    ownerId,
+    generation,
+    lineIndices: EMPTY_SELECTION_LINE_INDICES
+  })), heightIndexRef = useRef(null), heightIndex = heightIndexRef.current;
+  heightIndex === null && (heightIndex = new ViewportHeightIndex(), heightIndex.reset(totalLines, DEFAULT_CODE_LINE_HEIGHT), heightIndexRef.current = heightIndex);
+  let indexedCountRef = useRef(totalLines), totalLinesRef = useRef(totalLines);
+  totalLinesRef.current = totalLines;
+  let measuredWidthRef = useRef(null), measurementGenerationRef = useRef(0), previousScrollTopRef = useRef(null), followTailRef = useRef(!1), followTailOptInRef = useRef(config.followTail === !0);
+  followTailOptInRef.current = config.followTail === !0, followTailOptInRef.current || (followTailRef.current = !1);
+  let writeScrollTop = useCallback((container, nextTop) => {
+    container.scrollTop = nextTop, previousScrollTopRef.current = container.scrollTop;
+  }, []), viewportAnchorRef = useRef(null), geometryIdentityRef = useRef(null), printOwnerGenerationRef = useRef(0), [printOwner, setPrintOwner] = useState(null), isPrintingRef = useRef(!1), printGeometrySuspendedRef = useRef(!1), restoringPrintScrollRef = useRef(!1), printSnapshotRef = useRef(null), rowResizeObserverRef = useRef(null), printRowsRef = useRef(/* @__PURE__ */ new Set()), printEligible = config.enabled && totalLines >= config.virtualizeThreshold, isPrinting = printOwner?.identity === ownerIdentity && printOwner.generation === printOwnerGenerationRef.current, previousIdentity = geometryIdentityRef.current;
+  previousIdentity === null && (previousIdentity = {
+    ownerId,
+    ownerIdentity,
+    generation,
+    configurationRevision,
+    enabled: config.enabled,
+    windowSize: config.windowSize,
+    bufferSize: config.bufferSize,
+    virtualizeThreshold: config.virtualizeThreshold
+  }, geometryIdentityRef.current = previousIdentity);
+  let geometryReady = previousIdentity.ownerId === ownerId && previousIdentity.ownerIdentity === ownerIdentity && previousIdentity.generation === generation && previousIdentity.configurationRevision === configurationRevision && previousIdentity.enabled === config.enabled && previousIdentity.windowSize === config.windowSize && previousIdentity.bufferSize === config.bufferSize && previousIdentity.virtualizeThreshold === config.virtualizeThreshold && indexedCountRef.current === totalLines, selectionLineIndices = selectionState.ownerId === ownerId && selectionState.generation === generation ? selectionState.lineIndices : EMPTY_SELECTION_LINE_INDICES, selectionTrackingEnabled = config.enabled && totalLines >= config.virtualizeThreshold, refreshSelection = useCallback(() => {
+    let container = containerRef.current;
+    if (!container || !selectionTrackingEnabled) return;
+    let selection = container.ownerDocument.getSelection(), nextLineIndices = [], retainEndpoint = (node) => {
+      if (!node) return;
+      let row = (node.nodeType === 1 ? node : node.parentElement)?.closest(".line[data-line]");
+      if (!row || !container.contains(row)) return;
+      let lineNumber = Number(row.getAttribute("data-line")), lineIndex = lineNumber - 1;
+      !Number.isSafeInteger(lineNumber) || lineNumber <= 0 || lineIndex >= totalLinesRef.current || nextLineIndices.includes(lineIndex) || nextLineIndices.push(lineIndex);
+    };
+    selection && selection.rangeCount > 0 && (retainEndpoint(selection.anchorNode), retainEndpoint(selection.focusNode)), nextLineIndices.sort((left, right) => left - right), setSelectionState((previous) => previous.ownerId === ownerId && previous.generation === generation && previous.lineIndices.length === nextLineIndices.length && previous.lineIndices.every((lineIndex, index) => lineIndex === nextLineIndices[index]) ? previous : { ownerId, generation, lineIndices: nextLineIndices });
+  }, [generation, ownerId, selectionTrackingEnabled]), layout = useMemo(() => {
+    if (geometryReady)
+      return calculateMeasuredCodeWindow(totalLines, scrollTop, containerHeight, heightIndex, config);
+    let window = calculateCodeWindow(
+      totalLines,
+      scrollTop,
+      containerHeight,
+      DEFAULT_CODE_LINE_HEIGHT,
+      config
+    ), virtualized = config.enabled && totalLines >= config.virtualizeThreshold;
+    return {
+      window,
+      spacerTopHeight: virtualized ? window.startIndex * DEFAULT_CODE_LINE_HEIGHT : 0,
+      spacerBottomHeight: virtualized ? (window.totalLines - window.endIndex) * DEFAULT_CODE_LINE_HEIGHT : 0
+    };
+  }, [config, containerHeight, geometryReady, heightIndex, measureVersion, scrollTop, totalLines]), renderLayout = useMemo(() => {
+    let intervals = [], primary = layout.window;
+    primary.endIndex > primary.startIndex && intervals.push({
+      startIndex: primary.startIndex,
+      endIndex: primary.endIndex,
+      visibleStart: primary.visibleStart,
+      visibleEnd: primary.visibleEnd
+    });
+    for (let lineIndex of selectionLineIndices) {
+      if (!Number.isSafeInteger(lineIndex) || lineIndex < 0 || lineIndex >= totalLines || lineIndex >= primary.startIndex && lineIndex < primary.endIndex)
+        continue;
+      let previous = intervals[intervals.length - 1];
+      previous && (previous.startIndex !== primary.startIndex || previous.endIndex !== primary.endIndex) && previous.endIndex === lineIndex ? (previous.endIndex += 1, previous.visibleEnd = lineIndex + 1) : intervals.push({
+        startIndex: lineIndex,
+        endIndex: lineIndex + 1,
+        visibleStart: lineIndex,
+        visibleEnd: lineIndex + 1
+      });
+    }
+    intervals.sort((left, right) => left.startIndex - right.startIndex);
+    let offsetAt = geometryReady ? (index) => heightIndex.offsetAt(index) : (index) => index * DEFAULT_CODE_LINE_HEIGHT, previousEnd = 0, mountedLines = 0, ranges = intervals.map((interval, index) => {
+      let spacerBeforeHeight = index === 0 ? 0 : Math.max(0, offsetAt(interval.startIndex) - offsetAt(previousEnd));
+      return previousEnd = interval.endIndex, mountedLines += interval.endIndex - interval.startIndex, { ...interval, spacerBeforeHeight };
+    });
+    return {
+      ranges,
+      spacerTopHeight: ranges.length > 0 ? offsetAt(ranges[0].startIndex) : 0,
+      spacerBottomHeight: Math.max(0, offsetAt(totalLines) - offsetAt(previousEnd)),
+      mountedLines
+    };
+  }, [geometryReady, heightIndex, layout.window, selectionLineIndices, totalLines]);
   useEffect(() => {
-    if (!containerRef.current || lines.length === 0) return;
-    const timeoutId = setTimeout(() => {
-      if (!containerRef.current) return;
-      const firstLine = containerRef.current.querySelector(".line");
-      if (firstLine) {
-        const measuredHeight = firstLine.offsetHeight || 20;
-        if (measuredHeight !== lineHeightRef.current) {
-          lineHeightRef.current = measuredHeight;
-        }
+    let container = containerRef.current;
+    if (!container || !selectionTrackingEnabled) return;
+    let ownerDocument = container.ownerDocument;
+    return ownerDocument.addEventListener("selectionchange", refreshSelection), refreshSelection(), () => ownerDocument.removeEventListener("selectionchange", refreshSelection);
+  }, [refreshSelection, selectionTrackingEnabled]), useEffect(() => {
+    let container = containerRef.current;
+    if (!container || config.followTail !== !0) return;
+    let scrollTop2 = container.scrollTop, distanceToBottom = container.scrollHeight - container.clientHeight - scrollTop2;
+    followTailRef.current = distanceToBottom <= CODE_FOLLOW_TAIL_EPS_BOTTOM_PX, previousScrollTopRef.current = scrollTop2;
+  }, [config.followTail]), useEffect(() => {
+    if (!printEligible) return;
+    let container = containerRef.current;
+    if (!container) return;
+    let ownerWindow = container.ownerDocument.defaultView;
+    if (!ownerWindow) return;
+    let owner = ++printOwnerGenerationRef.current, active = !0, isCurrentOwner = () => active && printOwnerGenerationRef.current === owner && containerRef.current === container, onBeforePrint = () => {
+      if (!isCurrentOwner() || !container.isConnected || isPrintingRef.current) return;
+      isPrintingRef.current = !0, printGeometrySuspendedRef.current = !0, printSnapshotRef.current = {
+        identity: ownerIdentity,
+        owner,
+        scrollTop: container.scrollTop,
+        followTail: followTailRef.current,
+        anchor: viewportAnchorRef.current
+      }, flushSync(() => {
+        setPrintOwner({ identity: ownerIdentity, generation: owner });
+      });
+      let observer = rowResizeObserverRef.current;
+      if (observer)
+        for (let row of container.querySelectorAll(".line[data-line]"))
+          observer.observe(row), printRowsRef.current.add(row);
+    }, onAfterPrint = () => {
+      if (!isCurrentOwner() || !isPrintingRef.current) return;
+      let snapshot = printSnapshotRef.current;
+      if (!snapshot || snapshot.owner !== owner) return;
+      let restoreReader = snapshot.identity === ownerIdentity && container.isConnected;
+      restoreReader && (restoringPrintScrollRef.current = !0), isPrintingRef.current = !1, printSnapshotRef.current = null, flushSync(() => {
+        setPrintOwner((current) => current?.generation === owner ? null : current);
+      }), restoreReader && (followTailRef.current = snapshot.followTail && followTailOptInRef.current, viewportAnchorRef.current = snapshot.anchor, flushSync(() => setScrollTop(container.scrollTop)));
+      let observer = rowResizeObserverRef.current;
+      for (let row of printRowsRef.current)
+        container.contains(row) || observer?.unobserve(row);
+      printRowsRef.current.clear(), ownerWindow.requestAnimationFrame(() => {
+        !isCurrentOwner() || isPrintingRef.current || (restoreReader && (restoringPrintScrollRef.current = !1), printGeometrySuspendedRef.current = !1);
+      });
+    };
+    return ownerWindow.addEventListener("beforeprint", onBeforePrint), ownerWindow.addEventListener("afterprint", onAfterPrint), () => {
+      if (active = !1, ownerWindow.removeEventListener("beforeprint", onBeforePrint), ownerWindow.removeEventListener("afterprint", onAfterPrint), printOwnerGenerationRef.current !== owner) return;
+      printOwnerGenerationRef.current++, restoringPrintScrollRef.current = !1, printGeometrySuspendedRef.current = !1, isPrintingRef.current = !1, printSnapshotRef.current = null;
+      let observer = rowResizeObserverRef.current;
+      for (let row of printRowsRef.current)
+        container.contains(row) || observer?.unobserve(row);
+      printRowsRef.current.clear();
+    };
+  }, [ownerIdentity, printEligible]), useEffect(() => {
+    let previous = geometryIdentityRef.current;
+    if (!previous) return;
+    let ownerChanged = previous.ownerId !== ownerId || previous.ownerIdentity !== ownerIdentity || previous.generation !== generation, sourceConfigurationChanged = previous.configurationRevision !== configurationRevision, presentationOptionsChanged = previous.enabled !== config.enabled || previous.windowSize !== config.windowSize || previous.bufferSize !== config.bufferSize || previous.virtualizeThreshold !== config.virtualizeThreshold, lineCountChanged = indexedCountRef.current !== totalLines;
+    if (ownerChanged || sourceConfigurationChanged)
+      heightIndex.reset(totalLines, DEFAULT_CODE_LINE_HEIGHT), indexedCountRef.current = totalLines, viewportAnchorRef.current = null;
+    else if (lineCountChanged) {
+      let previousCount = indexedCountRef.current;
+      if (heightIndex.resize(totalLines), indexedCountRef.current = totalLines, totalLines < previousCount) {
+        let anchor = viewportAnchorRef.current;
+        anchor && anchor.lineIndex >= totalLines && (viewportAnchorRef.current = null);
+      }
+      let container = containerRef.current;
+      if (totalLines > previousCount && container && followTailRef.current && !isPrintingRef.current && !printGeometrySuspendedRef.current && !restoringPrintScrollRef.current) {
+        let nextScrollTop = Math.max(0, container.scrollHeight - container.clientHeight);
+        container.scrollTop !== nextScrollTop && (writeScrollTop(container, nextScrollTop), setScrollTop(nextScrollTop));
       }
-    }, 0);
-    return () => clearTimeout(timeoutId);
-  }, [lines.length]);
-  const handleScroll = useCallback((e) => {
-    const target = e.currentTarget;
-    setScrollTop(target.scrollTop);
-    setContainerHeight(target.clientHeight);
-  }, []);
+    }
+    if (ownerChanged) {
+      followTailRef.current = !1;
+      let container = containerRef.current;
+      container && (container.scrollTop !== 0 ? writeScrollTop(container, 0) : previousScrollTopRef.current = 0), setScrollTop(0);
+    }
+    (ownerChanged || sourceConfigurationChanged || presentationOptionsChanged || lineCountChanged) && ((ownerChanged || sourceConfigurationChanged || presentationOptionsChanged) && (measurementGenerationRef.current += 1), setMeasureVersion((version) => version + 1)), geometryIdentityRef.current = {
+      ownerId,
+      ownerIdentity,
+      generation,
+      configurationRevision,
+      enabled: config.enabled,
+      windowSize: config.windowSize,
+      bufferSize: config.bufferSize,
+      virtualizeThreshold: config.virtualizeThreshold
+    };
+  }, [
+    config.bufferSize,
+    config.enabled,
+    config.virtualizeThreshold,
+    config.windowSize,
+    configurationRevision,
+    generation,
+    heightIndex,
+    ownerId,
+    ownerIdentity,
+    totalLines,
+    writeScrollTop
+  ]), useEffect(() => {
+    let container = containerRef.current;
+    if (!container || typeof ResizeObserver > "u") return;
+    let resizeObserver = new ResizeObserver((entries) => {
+      if (!(isPrintingRef.current || printGeometrySuspendedRef.current || restoringPrintScrollRef.current))
+        for (let entry of entries) {
+          if (entry.target !== container) continue;
+          let nextHeight = Math.ceil(entry.contentRect.height || container.clientHeight);
+          setContainerHeight((current) => current === nextHeight ? current : nextHeight);
+          let nextWidth = Math.ceil(container.clientWidth || entry.contentRect.width), previousWidth = measuredWidthRef.current;
+          if (previousWidth === null)
+            measuredWidthRef.current = nextWidth;
+          else if (previousWidth !== nextWidth) {
+            measuredWidthRef.current = nextWidth;
+            let lineCount = totalLinesRef.current;
+            heightIndex.reset(lineCount, DEFAULT_CODE_LINE_HEIGHT), indexedCountRef.current = lineCount, measurementGenerationRef.current += 1, viewportAnchorRef.current = null, setMeasureVersion((version) => version + 1);
+          }
+          setContainerWidth((current) => current === nextWidth ? current : nextWidth);
+        }
+    });
+    return resizeObserver.observe(container), () => resizeObserver.disconnect();
+  }, [heightIndex]);
+  let handleScroll = useCallback((event) => {
+    let target = event.currentTarget;
+    if (target !== containerRef.current || isPrintingRef.current || restoringPrintScrollRef.current) return;
+    refreshSelection();
+    let nextScrollTop = target.scrollTop, previousScrollTop = previousScrollTopRef.current, scrolledUp = previousScrollTop !== null && previousScrollTop - nextScrollTop > CODE_FOLLOW_TAIL_DETACH_SCROLL_DELTA_PX;
+    previousScrollTopRef.current = nextScrollTop, setScrollTop(nextScrollTop), setContainerHeight(target.clientHeight);
+    let atBottom = target.scrollHeight - target.clientHeight - nextScrollTop <= CODE_FOLLOW_TAIL_EPS_BOTTOM_PX;
+    if (config.followTail !== !0 || scrolledUp ? followTailRef.current = !1 : atBottom && (followTailRef.current = !0), atBottom && !scrolledUp) {
+      viewportAnchorRef.current = null;
+      return;
+    }
+    let lineIndex = Math.min(
+      Math.max(0, totalLines - 1),
+      geometryReady ? heightIndex.indexAt(nextScrollTop) : Math.floor(Math.max(0, nextScrollTop) / DEFAULT_CODE_LINE_HEIGHT)
+    ), lineTop = geometryReady ? heightIndex.offsetAt(lineIndex) : lineIndex * DEFAULT_CODE_LINE_HEIGHT;
+    viewportAnchorRef.current = {
+      lineIndex,
+      offset: lineTop - nextScrollTop,
+      ownerId,
+      ownerIdentity,
+      generation,
+      configurationRevision
+    };
+  }, [config.followTail, configurationRevision, generation, geometryReady, heightIndex, ownerId, ownerIdentity, refreshSelection, totalLines]);
   useEffect(() => {
-    if (!containerRef.current) return;
-    const resizeObserver = new ResizeObserver((entries) => {
-      for (const entry of entries) {
-        setContainerHeight(entry.contentRect.height);
+    let container = containerRef.current;
+    if (!container || !geometryReady || !config.enabled || totalLines < config.virtualizeThreshold)
+      return;
+    let measurementGeneration = measurementGenerationRef.current, active = !0, preserveViewport = () => {
+      if (!active || measurementGenerationRef.current !== measurementGeneration || isPrintingRef.current || printGeometrySuspendedRef.current || restoringPrintScrollRef.current) return;
+      if (followTailRef.current) {
+        let nextScrollTop2 = Math.max(0, container.scrollHeight - container.clientHeight);
+        container.scrollTop !== nextScrollTop2 && (writeScrollTop(container, nextScrollTop2), setScrollTop(nextScrollTop2));
+        return;
       }
+      let anchor = viewportAnchorRef.current;
+      if (!anchor || anchor.ownerId !== ownerId || anchor.ownerIdentity !== ownerIdentity || anchor.generation !== generation || anchor.configurationRevision !== configurationRevision)
+        return;
+      let lineIndex = Math.min(Math.max(0, totalLines - 1), anchor.lineIndex), nextScrollTop = Math.max(0, heightIndex.offsetAt(lineIndex) - anchor.offset);
+      Math.abs(container.scrollTop - nextScrollTop) > 0.5 && (writeScrollTop(container, nextScrollTop), setScrollTop(nextScrollTop));
+    }, measureRow = (row) => {
+      if (isPrintingRef.current || printGeometrySuspendedRef.current || restoringPrintScrollRef.current || !row.matches(".line[data-line]") || !container.contains(row)) return !1;
+      let lineIndex = Number(row.getAttribute("data-line")) - 1;
+      if (!Number.isSafeInteger(lineIndex) || lineIndex < 0 || lineIndex >= totalLines) return !1;
+      let element = row, height = element.getBoundingClientRect().height || element.offsetHeight;
+      return height > 0 && heightIndex.setHeight(lineIndex, height);
+    }, observer = typeof ResizeObserver > "u" ? null : new ResizeObserver((entries) => {
+      if (!active || measurementGenerationRef.current !== measurementGeneration || isPrintingRef.current || printGeometrySuspendedRef.current || restoringPrintScrollRef.current) return;
+      let changed2 = !1;
+      for (let entry of entries) changed2 = measureRow(entry.target) || changed2;
+      changed2 && (preserveViewport(), setMeasureVersion((version) => version + 1));
     });
-    resizeObserver.observe(containerRef.current);
-    return () => resizeObserver.disconnect();
-  }, []);
-  const window = useMemo(() => {
-    return calculateCodeWindow(lines, scrollTop, containerHeight, lineHeightRef.current, config);
-  }, [lines, scrollTop, containerHeight, config]);
-  const scrollToLine = useCallback((lineIndex) => {
-    if (!containerRef.current) return;
-    const targetScrollTop = lineIndex * lineHeightRef.current;
-    containerRef.current.scrollTop = targetScrollTop;
-    setScrollTop(targetScrollTop);
-  }, []);
+    rowResizeObserverRef.current = observer;
+    let changed = !1, rows = container.querySelectorAll(".line[data-line]");
+    for (let row of rows)
+      observer?.observe(row), isPrintingRef.current && printRowsRef.current.add(row), changed = measureRow(row) || changed;
+    return changed && (preserveViewport(), setMeasureVersion((version) => version + 1)), () => {
+      rowResizeObserverRef.current === observer && (rowResizeObserverRef.current = null), observer?.disconnect(), printRowsRef.current.clear();
+    };
+  }, [
+    config.enabled,
+    config.virtualizeThreshold,
+    configurationRevision,
+    generation,
+    geometryReady,
+    heightIndex,
+    layout.window.endIndex,
+    layout.window.startIndex,
+    ownerIdentity,
+    ownerId,
+    totalLines,
+    containerWidth,
+    selectionLineIndices,
+    writeScrollTop
+  ]);
+  let scrollToLine = useCallback((lineIndex) => {
+    let container = containerRef.current;
+    if (!container || isPrintingRef.current || printGeometrySuspendedRef.current || restoringPrintScrollRef.current) return;
+    let targetIndex = Math.max(0, Math.min(Math.floor(lineIndex), totalLines - 1)), targetScrollTop = geometryReady ? heightIndex.offsetAt(targetIndex) : targetIndex * DEFAULT_CODE_LINE_HEIGHT;
+    writeScrollTop(container, targetScrollTop), setScrollTop(targetScrollTop), followTailRef.current = !1, viewportAnchorRef.current = {
+      lineIndex: targetIndex,
+      offset: 0,
+      ownerId,
+      ownerIdentity,
+      generation,
+      configurationRevision
+    };
+  }, [configurationRevision, generation, geometryReady, heightIndex, ownerId, ownerIdentity, totalLines, writeScrollTop]), lineHeight = heightIndex.offsetAt(1) - heightIndex.offsetAt(0) || DEFAULT_CODE_LINE_HEIGHT;
   return {
     containerRef,
-    window,
+    isPrinting,
+    selectionLineIndices,
+    window: layout.window,
+    renderRanges: renderLayout.ranges,
+    mountedLineCount: renderLayout.mountedLines,
+    spacerTopHeight: renderLayout.spacerTopHeight,
+    spacerBottomHeight: renderLayout.spacerBottomHeight,
     handleScroll,
     scrollToLine,
-    lineHeight: lineHeightRef.current,
+    lineHeight,
     config
   };
 }
 export {
   DEFAULT_VIRTUALIZED_CODE_CONFIG,
   calculateCodeWindow,
+  resolveVirtualizedCodeConfig,
   useVirtualizedCode
 };