@gunkin/uiify 0.0.1-alpha

package/dist/components/virtual-scroll/VirtualScroll.js

@@ -0,0 +1,459 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import {
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { flushSync } from "react-dom";
+import { useResizeObserver } from "@gunkin/uiify/hooks";
+import { resolveVirtualScrollAnchorAdjustment } from "./virtual-scroll-anchor.js";
+import {
+  createVirtualScrollIosScroll,
+  detectTouchScrollEnvironment
+} from "./virtual-scroll-ios.js";
+import {
+  computeScrollAdjustmentForRowResize,
+  createVirtualScrollMeasurementStore
+} from "./virtual-scroll-measurements.js";
+import {
+  computeDynamicVirtualScrollRange,
+  computeVirtualScrollRange,
+  rangesEqual,
+  toVirtualScrollRangeChange
+} from "./virtual-scroll-range.js";
+import {
+  computeActiveVirtualScrollSlotCount,
+  computeVirtualScrollSlotCount,
+  VirtualScrollRowShell
+} from "./VirtualScrollRowShell.js";
+import {
+  clampScrollOffset,
+  computeScrollOffsetForIndex,
+  isSmoothScrollActive,
+  normalizeScrollBehaviorOptions,
+  normalizeScrollToIndexOptions,
+  resolveScrollBehavior
+} from "./virtual-scroll-scroll.js";
+import {
+  createVirtualScrollScrollState,
+  supportsScrollEndEvent
+} from "./virtual-scroll-scroll-state.js";
+import { applyVirtualScrollRangeToDom } from "./virtual-scroll-scroll-sync.js";
+import { VirtualScrollRowItem } from "./VirtualScrollRowItem.js";
+import {
+  VIRTUAL_SCROLL_OVERSCAN,
+  VIRTUAL_SCROLL_ROW_HEIGHT,
+  VIRTUAL_SCROLL_SCROLL_RESET_DELAY
+} from "./types.js";
+function buildRowSlots(items, rangeStart, slotCount) {
+  const activeSlotCount = computeActiveVirtualScrollSlotCount(items.length, rangeStart, slotCount);
+  return Array.from({ length: activeSlotCount }, (_, slotIndex) => {
+    const index = rangeStart + slotIndex;
+    return {
+      index,
+      item: items[index] ?? null,
+      slotIndex
+    };
+  });
+}
+function VirtualScroll(props) {
+  const {
+    items,
+    height = 600,
+    rowHeight = VIRTUAL_SCROLL_ROW_HEIGHT,
+    overscan = VIRTUAL_SCROLL_OVERSCAN,
+    className,
+    testId,
+    renderRow,
+    scrollRef,
+    estimateRowHeight,
+    onRangeChange,
+    role = "list",
+    anchor = "start",
+    followAppend = false,
+    onScrollStateChange,
+    isScrollingResetDelay = VIRTUAL_SCROLL_SCROLL_RESET_DELAY
+  } = props;
+  const dynamicLayout = estimateRowHeight !== void 0;
+  const ref = useRef(null);
+  const scrollTopRef = useRef(0);
+  const itemsRef = useRef(items);
+  itemsRef.current = items;
+  const smoothRafRef = useRef(0);
+  const lastRangeChangeRef = useRef("");
+  const measuredHeightsRef = useRef(/* @__PURE__ */ new Map());
+  const anchorSnapshotRef = useRef({
+    firstItemId: items[0]?.id,
+    itemCount: items.length,
+    totalSize: 0,
+    scrollTop: 0
+  });
+  const [rangeVersion, setRangeVersion] = useState(0);
+  const [measurementVersion, setMeasurementVersion] = useState(0);
+  const measuredSize = useResizeObserver(ref);
+  const viewportHeight = measuredSize?.height ?? height;
+  const measurementStoreRef = useRef(
+    createVirtualScrollMeasurementStore({
+      itemCount: items.length,
+      defaultRowHeight: rowHeight,
+      ...estimateRowHeight ? { estimateRowHeight } : {},
+      measuredHeights: measuredHeightsRef.current,
+      itemIdAtIndex: (index) => itemsRef.current[index]?.id
+    })
+  );
+  measurementStoreRef.current.syncItemCount(items.length);
+  const scrollOptionsRef = useRef({
+    dynamicLayout,
+    itemCount: items.length,
+    overscan,
+    rowHeight,
+    viewportHeight
+  });
+  scrollOptionsRef.current = {
+    dynamicLayout,
+    itemCount: items.length,
+    overscan,
+    rowHeight,
+    viewportHeight
+  };
+  const onRangeChangeRef = useRef(onRangeChange);
+  onRangeChangeRef.current = onRangeChange;
+  const onScrollStateChangeRef = useRef(onScrollStateChange);
+  onScrollStateChangeRef.current = onScrollStateChange;
+  const computeRange = () => {
+    const { dynamicLayout: dynamicLayout2, itemCount, overscan: overscan2, rowHeight: rowHeight2, viewportHeight: viewportHeight2 } = scrollOptionsRef.current;
+    const scrollTop = scrollTopRef.current;
+    if (dynamicLayout2) {
+      const store = measurementStoreRef.current;
+      return computeDynamicVirtualScrollRange({
+        scrollTop,
+        viewportHeight: viewportHeight2,
+        itemCount,
+        overscan: overscan2,
+        findStartIndex: store.findStartIndex,
+        findEndIndex: store.findEndIndex,
+        getRowOffset: store.getRowOffset
+      });
+    }
+    return computeVirtualScrollRange({
+      scrollTop,
+      viewportHeight: viewportHeight2,
+      itemCount,
+      rowHeight: rowHeight2,
+      overscan: overscan2
+    });
+  };
+  const emitRangeChange = (range2) => {
+    const callback = onRangeChangeRef.current;
+    if (!callback) return;
+    const payload = toVirtualScrollRangeChange(range2);
+    const signature = `${payload.overscanStart}:${payload.overscanEnd}`;
+    if (signature === lastRangeChangeRef.current) return;
+    lastRangeChangeRef.current = signature;
+    callback(payload);
+  };
+  const syncRangeFromScrollRef = useRef(() => {
+  });
+  syncRangeFromScrollRef.current = () => {
+    const element = ref.current;
+    if (!element) return;
+    const scrollTop = element.scrollTop;
+    const previousRange = computeRange();
+    scrollTopRef.current = scrollTop;
+    const nextRange = computeRange();
+    if (rangesEqual(previousRange, nextRange)) return;
+    emitRangeChange(nextRange);
+    const { dynamicLayout: dynamicLayout2, itemCount, viewportHeight: viewportHeight2, rowHeight: rowHeight2, overscan: overscan2 } = scrollOptionsRef.current;
+    const slotCount2 = computeActiveVirtualScrollSlotCount(
+      itemCount,
+      nextRange.start,
+      Math.max(
+        nextRange.end - nextRange.start,
+        computeVirtualScrollSlotCount(viewportHeight2, rowHeight2, overscan2)
+      )
+    );
+    const store = measurementStoreRef.current;
+    applyVirtualScrollRangeToDom(element, nextRange, {
+      dynamicLayout: dynamicLayout2,
+      slotCount: slotCount2,
+      getRowOffset: store.getRowOffset.bind(store)
+    });
+    flushSync(() => {
+      setRangeVersion((version) => version + 1);
+    });
+  };
+  const iosControllerRef = useRef(
+    createVirtualScrollIosScroll({
+      enabled: detectTouchScrollEnvironment(),
+      resetDelay: isScrollingResetDelay
+    })
+  );
+  const applyScrollDeltaRef = useRef((_delta) => {
+  });
+  applyScrollDeltaRef.current = (delta) => {
+    const element = ref.current;
+    if (!element || delta === 0) return;
+    element.scrollTop += delta;
+    syncRangeFromScrollRef.current();
+  };
+  const applyScrollOffset = (offset, behavior) => {
+    const element = ref.current;
+    if (!element) return;
+    const store = measurementStoreRef.current;
+    const totalSize2 = dynamicLayout ? store.getTotalSize() : items.length * rowHeight;
+    const clamped = clampScrollOffset(offset, totalSize2, viewportHeight);
+    const resolved = resolveScrollBehavior(behavior);
+    if (typeof element.scrollTo === "function") {
+      element.scrollTo({ top: clamped, behavior: resolved });
+    } else {
+      element.scrollTop = clamped;
+    }
+    syncRangeFromScrollRef.current();
+    if (isSmoothScrollActive(behavior ?? "auto", element.scrollTop, clamped)) {
+      if (smoothRafRef.current !== 0) cancelAnimationFrame(smoothRafRef.current);
+      const tick = () => {
+        syncRangeFromScrollRef.current();
+        const node = ref.current;
+        if (!node) {
+          smoothRafRef.current = 0;
+          return;
+        }
+        if (isSmoothScrollActive("smooth", node.scrollTop, clamped)) {
+          smoothRafRef.current = requestAnimationFrame(tick);
+          return;
+        }
+        smoothRafRef.current = 0;
+      };
+      smoothRafRef.current = requestAnimationFrame(tick);
+    }
+  };
+  const applyScrollOffsetRef = useRef(
+    (_offset, _behavior) => {
+    }
+  );
+  applyScrollOffsetRef.current = applyScrollOffset;
+  useImperativeHandle(
+    scrollRef,
+    () => ({
+      get element() {
+        return ref.current;
+      },
+      scrollToIndex(index, options) {
+        const normalized = normalizeScrollToIndexOptions(options);
+        const store = measurementStoreRef.current;
+        const metrics = {
+          getRowOffset: store.getRowOffset.bind(store),
+          getRowHeight: store.getRowHeight.bind(store),
+          getTotalSize: store.getTotalSize.bind(store)
+        };
+        const offset = computeScrollOffsetForIndex(
+          index,
+          normalized.align,
+          metrics,
+          scrollOptionsRef.current.viewportHeight,
+          scrollTopRef.current
+        );
+        applyScrollOffsetRef.current(offset, normalized.behavior);
+      },
+      scrollToOffset(offset, options) {
+        applyScrollOffsetRef.current(offset, normalizeScrollBehaviorOptions(options));
+      },
+      scrollToEnd(options) {
+        const store = measurementStoreRef.current;
+        const totalSize2 = dynamicLayout ? store.getTotalSize() : scrollOptionsRef.current.itemCount * scrollOptionsRef.current.rowHeight;
+        const offset = Math.max(0, totalSize2 - scrollOptionsRef.current.viewportHeight);
+        applyScrollOffsetRef.current(offset, normalizeScrollBehaviorOptions(options));
+      }
+    }),
+    [dynamicLayout]
+  );
+  const range = useMemo(() => {
+    void rangeVersion;
+    void measurementVersion;
+    return computeRange();
+  }, [rangeVersion, measurementVersion]);
+  const totalSize = useMemo(() => {
+    void measurementVersion;
+    if (dynamicLayout) return measurementStoreRef.current.getTotalSize();
+    return items.length * rowHeight;
+  }, [dynamicLayout, items.length, measurementVersion, rowHeight]);
+  const slotCount = useMemo(() => {
+    if (items.length === 0) return 0;
+    return Math.max(
+      range.end - range.start,
+      computeVirtualScrollSlotCount(viewportHeight, rowHeight, overscan)
+    );
+  }, [items.length, overscan, range.end, range.start, rowHeight, viewportHeight]);
+  const rowSlots = useMemo(
+    () => buildRowSlots(items, range.start, slotCount),
+    [items, range.start, slotCount]
+  );
+  const handleRowMeasureRef = useRef((index, itemId, height2) => {
+    const store = measurementStoreRef.current;
+    const previousHeight = store.getRowHeight(index);
+    const rowOffset = store.getRowOffset(index);
+    if (!store.setMeasuredHeight(itemId, index, height2)) return;
+    const adjustment = computeScrollAdjustmentForRowResize({
+      scrollTop: scrollTopRef.current,
+      rowOffset,
+      previousHeight,
+      nextHeight: height2
+    });
+    if (adjustment > 0) {
+      const ios = iosControllerRef.current;
+      if (ios.isTouchScrolling()) {
+        ios.queueAdjustment(adjustment);
+      } else {
+        applyScrollDeltaRef.current(adjustment);
+      }
+    }
+    setMeasurementVersion((version) => version + 1);
+  });
+  const rowsFragmentRef = useRef(null);
+  useEffect(() => {
+    if (!dynamicLayout) return;
+    const fragment = rowsFragmentRef.current;
+    if (!fragment || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const target = entry.target;
+        if (!(target instanceof HTMLElement)) continue;
+        const raw = target.dataset["uiifyRowIndex"];
+        if (raw === void 0) continue;
+        const index = Number(raw);
+        if (!Number.isInteger(index)) continue;
+        const itemId = itemsRef.current[index]?.id;
+        if (itemId === void 0) continue;
+        handleRowMeasureRef.current(index, itemId, entry.contentRect.height);
+      }
+    });
+    fragment.observeUsing(observer);
+    return () => fragment.unobserveUsing(observer);
+  }, [dynamicLayout]);
+  useEffect(() => {
+    const element = ref.current;
+    if (!element) return;
+    const scrollState = createVirtualScrollScrollState({
+      resetDelay: isScrollingResetDelay,
+      supportsScrollEnd: supportsScrollEndEvent(),
+      onChange: (isScrolling) => {
+        onScrollStateChangeRef.current?.({ isScrolling });
+        if (!isScrolling) {
+          iosControllerRef.current.flushAdjustments(applyScrollDeltaRef.current);
+        }
+      }
+    });
+    let onScroll = null;
+    let onScrollEnd = null;
+    const ios = iosControllerRef.current;
+    const onTouchStart = () => ios.onTouchStart();
+    const onTouchEnd = () => ios.onTouchEnd();
+    onScroll = () => {
+      scrollState.notifyScroll();
+      syncRangeFromScrollRef.current();
+    };
+    element.addEventListener("scroll", onScroll, { passive: true });
+    if (supportsScrollEndEvent()) {
+      onScrollEnd = () => {
+        scrollState.notifyScrollEnd();
+        syncRangeFromScrollRef.current();
+      };
+      element.addEventListener("scrollend", onScrollEnd, { passive: true });
+    }
+    element.addEventListener("touchstart", onTouchStart, { passive: true });
+    element.addEventListener("touchend", onTouchEnd, { passive: true });
+    return () => {
+      if (smoothRafRef.current !== 0) cancelAnimationFrame(smoothRafRef.current);
+      if (onScroll) element.removeEventListener("scroll", onScroll);
+      if (onScrollEnd) element.removeEventListener("scrollend", onScrollEnd);
+      element.removeEventListener("touchstart", onTouchStart);
+      element.removeEventListener("touchend", onTouchEnd);
+      scrollState.dispose();
+    };
+  }, [isScrollingResetDelay]);
+  useEffect(() => {
+    const element = ref.current;
+    const store = measurementStoreRef.current;
+    const nextTotalSize = dynamicLayout ? store.getTotalSize() : items.length * rowHeight;
+    const previous = anchorSnapshotRef.current;
+    const nextSnapshot = {
+      firstItemId: items[0]?.id,
+      itemCount: items.length,
+      totalSize: nextTotalSize,
+      scrollTop: element?.scrollTop ?? scrollTopRef.current
+      // banned-read-ok: anchor snapshot reads native position.
+    };
+    const adjustment = resolveVirtualScrollAnchorAdjustment({
+      anchor,
+      followAppend,
+      viewportHeight,
+      previous,
+      next: nextSnapshot
+    });
+    if (adjustment && element) {
+      if (adjustment.behavior === "smooth" && typeof element.scrollTo === "function") {
+        element.scrollTo({
+          top: element.scrollTop + adjustment.delta,
+          // banned-read-ok: retain the anchored viewport.
+          behavior: "smooth"
+        });
+      } else {
+        element.scrollTop += adjustment.delta;
+      }
+      syncRangeFromScrollRef.current();
+    }
+    anchorSnapshotRef.current = nextSnapshot;
+  }, [anchor, followAppend, items, dynamicLayout, rowHeight, viewportHeight]);
+  useEffect(() => {
+    emitRangeChange(range);
+  }, [range]);
+  const scrollportStyle = {
+    height,
+    overflowY: "auto",
+    "--uiify-virtual-scroll-count": items.length,
+    "--uiify-virtual-scroll-row-height": `${rowHeight}px`,
+    ...dynamicLayout ? { "--uiify-virtual-scroll-total-size": `${totalSize}px` } : {}
+  };
+  const spacerStyle = dynamicLayout ? void 0 : {
+    "--uiify-range-start": range.start
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      "data-testid": testId,
+      "data-uiify-virtual-scroll": "",
+      "data-uiify-dynamic-layout": dynamicLayout ? "" : void 0,
+      role,
+      className,
+      style: scrollportStyle,
+      children: /* @__PURE__ */ jsx("div", { "data-uiify-virtual-scroll-spacer": "", style: spacerStyle, children: rowSlots.map((slot) => {
+        const store = measurementStoreRef.current;
+        const rowOffset = dynamicLayout ? store.getRowOffset(slot.index) : void 0;
+        const measuredRowHeight = dynamicLayout ? store.getRowHeight(slot.index) : void 0;
+        return /* @__PURE__ */ jsx(
+          VirtualScrollRowShell,
+          {
+            slotIndex: slot.slotIndex,
+            index: slot.index,
+            itemCount: items.length,
+            listRole: role,
+            dynamicLayout,
+            ...rowOffset !== void 0 ? { rowOffset } : {},
+            ...measuredRowHeight !== void 0 ? { rowHeight: measuredRowHeight } : {},
+            children: slot.item ? /* @__PURE__ */ jsx(VirtualScrollRowItem, { item: slot.item, index: slot.index, renderRow }) : null
+          },
+          `slot-${slot.slotIndex}`
+        );
+      }) })
+    }
+  );
+}
+VirtualScroll.displayName = "VirtualScroll";
+export {
+  VirtualScroll
+};
+//# sourceMappingURL=VirtualScroll.js.map

package/dist/components/virtual-scroll/VirtualScroll.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/virtual-scroll/VirtualScroll.tsx"],"sourcesContent":["\"use client\";\n\nimport {\n  useEffect,\n  useImperativeHandle,\n  useMemo,\n  useRef,\n  useState,\n  type CSSProperties,\n  type FragmentInstance,\n  type ReactElement,\n} from \"react\";\nimport { flushSync } from \"react-dom\";\nimport { useResizeObserver } from \"@gunkin/uiify/hooks\";\nimport { resolveVirtualScrollAnchorAdjustment } from \"./virtual-scroll-anchor.js\";\nimport {\n  createVirtualScrollIosScroll,\n  detectTouchScrollEnvironment,\n} from \"./virtual-scroll-ios.js\";\nimport {\n  computeScrollAdjustmentForRowResize,\n  createVirtualScrollMeasurementStore,\n} from \"./virtual-scroll-measurements.js\";\nimport {\n  computeDynamicVirtualScrollRange,\n  computeVirtualScrollRange,\n  rangesEqual,\n  toVirtualScrollRangeChange,\n} from \"./virtual-scroll-range.js\";\nimport {\n  computeActiveVirtualScrollSlotCount,\n  computeVirtualScrollSlotCount,\n  VirtualScrollRowShell,\n} from \"./VirtualScrollRowShell.js\";\nimport {\n  clampScrollOffset,\n  computeScrollOffsetForIndex,\n  isSmoothScrollActive,\n  normalizeScrollBehaviorOptions,\n  normalizeScrollToIndexOptions,\n  resolveScrollBehavior,\n} from \"./virtual-scroll-scroll.js\";\nimport {\n  createVirtualScrollScrollState,\n  supportsScrollEndEvent,\n} from \"./virtual-scroll-scroll-state.js\";\nimport { applyVirtualScrollRangeToDom } from \"./virtual-scroll-scroll-sync.js\";\nimport type {\n  VirtualScrollHandle,\n  VirtualScrollItem,\n  VirtualScrollOwnProps,\n  VirtualScrollRowSlot,\n  VirtualScrollScrollBehaviorOptions,\n  VirtualScrollScrollToIndexOptions,\n} from \"./types.js\";\nimport { VirtualScrollRowItem } from \"./VirtualScrollRowItem.js\";\nimport {\n  VIRTUAL_SCROLL_OVERSCAN,\n  VIRTUAL_SCROLL_ROW_HEIGHT,\n  VIRTUAL_SCROLL_SCROLL_RESET_DELAY,\n} from \"./types.js\";\n\nfunction buildRowSlots<T extends VirtualScrollItem>(\n  items: readonly T[],\n  rangeStart: number,\n  slotCount: number,\n): readonly VirtualScrollRowSlot<T>[] {\n  const activeSlotCount = computeActiveVirtualScrollSlotCount(items.length, rangeStart, slotCount);\n  return Array.from({ length: activeSlotCount }, (_, slotIndex) => {\n    const index = rangeStart + slotIndex;\n    return {\n      index,\n      item: items[index] ?? null,\n      slotIndex,\n    };\n  });\n}\n\nexport function VirtualScroll<T extends VirtualScrollItem>(\n  props: VirtualScrollOwnProps<T>,\n): ReactElement {\n  const {\n    items,\n    height = 600,\n    rowHeight = VIRTUAL_SCROLL_ROW_HEIGHT,\n    overscan = VIRTUAL_SCROLL_OVERSCAN,\n    className,\n    testId,\n    renderRow,\n    scrollRef,\n    estimateRowHeight,\n    onRangeChange,\n    role = \"list\",\n    anchor = \"start\",\n    followAppend = false,\n    onScrollStateChange,\n    isScrollingResetDelay = VIRTUAL_SCROLL_SCROLL_RESET_DELAY,\n  } = props;\n\n  const dynamicLayout = estimateRowHeight !== undefined;\n  const ref = useRef<HTMLDivElement>(null);\n  const scrollTopRef = useRef(0);\n  const itemsRef = useRef(items);\n  itemsRef.current = items;\n  const smoothRafRef = useRef(0);\n  const lastRangeChangeRef = useRef<string>(\"\");\n  const measuredHeightsRef = useRef(new Map<string, number>());\n  const anchorSnapshotRef = useRef({\n    firstItemId: items[0]?.id,\n    itemCount: items.length,\n    totalSize: 0,\n    scrollTop: 0,\n  });\n\n  const [rangeVersion, setRangeVersion] = useState(0);\n  const [measurementVersion, setMeasurementVersion] = useState(0);\n\n  const measuredSize = useResizeObserver(ref);\n  const viewportHeight = measuredSize?.height ?? height;\n\n  const measurementStoreRef = useRef(\n    createVirtualScrollMeasurementStore({\n      itemCount: items.length,\n      defaultRowHeight: rowHeight,\n      ...(estimateRowHeight ? { estimateRowHeight } : {}),\n      measuredHeights: measuredHeightsRef.current,\n      itemIdAtIndex: (index) => itemsRef.current[index]?.id,\n    }),\n  );\n\n  measurementStoreRef.current.syncItemCount(items.length);\n\n  const scrollOptionsRef = useRef({\n    dynamicLayout,\n    itemCount: items.length,\n    overscan,\n    rowHeight,\n    viewportHeight,\n  });\n  scrollOptionsRef.current = {\n    dynamicLayout,\n    itemCount: items.length,\n    overscan,\n    rowHeight,\n    viewportHeight,\n  };\n\n  const onRangeChangeRef = useRef(onRangeChange);\n  onRangeChangeRef.current = onRangeChange;\n\n  const onScrollStateChangeRef = useRef(onScrollStateChange);\n  onScrollStateChangeRef.current = onScrollStateChange;\n\n  const computeRange = (): ReturnType<typeof computeVirtualScrollRange> => {\n    const { dynamicLayout, itemCount, overscan, rowHeight, viewportHeight } =\n      scrollOptionsRef.current;\n    const scrollTop = scrollTopRef.current;\n\n    if (dynamicLayout) {\n      const store = measurementStoreRef.current;\n      return computeDynamicVirtualScrollRange({\n        scrollTop,\n        viewportHeight,\n        itemCount,\n        overscan,\n        findStartIndex: store.findStartIndex,\n        findEndIndex: store.findEndIndex,\n        getRowOffset: store.getRowOffset,\n      });\n    }\n\n    return computeVirtualScrollRange({\n      scrollTop,\n      viewportHeight,\n      itemCount,\n      rowHeight,\n      overscan,\n    });\n  };\n\n  const emitRangeChange = (range: ReturnType<typeof computeVirtualScrollRange>): void => {\n    const callback = onRangeChangeRef.current;\n    if (!callback) return;\n    const payload = toVirtualScrollRangeChange(range);\n    const signature = `${payload.overscanStart}:${payload.overscanEnd}`;\n    if (signature === lastRangeChangeRef.current) return;\n    lastRangeChangeRef.current = signature;\n    callback(payload);\n  };\n\n  const syncRangeFromScrollRef = useRef(() => {});\n\n  syncRangeFromScrollRef.current = () => {\n    const element = ref.current;\n    if (!element) return;\n\n    const scrollTop = element.scrollTop; // banned-read-ok: scroll position drives the virtual range.\n    const previousRange = computeRange();\n    scrollTopRef.current = scrollTop;\n\n    const nextRange = computeRange();\n    if (rangesEqual(previousRange, nextRange)) return;\n\n    emitRangeChange(nextRange);\n\n    const { dynamicLayout, itemCount, viewportHeight, rowHeight, overscan } =\n      scrollOptionsRef.current;\n    const slotCount = computeActiveVirtualScrollSlotCount(\n      itemCount,\n      nextRange.start,\n      Math.max(\n        nextRange.end - nextRange.start,\n        computeVirtualScrollSlotCount(viewportHeight, rowHeight, overscan),\n      ),\n    );\n    const store = measurementStoreRef.current;\n\n    // Write range CSS vars on the scroll handler so rows move in the same frame as scrollTop.\n    applyVirtualScrollRangeToDom(element, nextRange, {\n      dynamicLayout,\n      slotCount,\n      getRowOffset: store.getRowOffset.bind(store),\n    });\n\n    // Commit the visible slice synchronously so content matches scroll position on large jumps.\n    flushSync(() => {\n      setRangeVersion((version) => version + 1);\n    });\n  };\n\n  const iosControllerRef = useRef(\n    createVirtualScrollIosScroll({\n      enabled: detectTouchScrollEnvironment(),\n      resetDelay: isScrollingResetDelay,\n    }),\n  );\n\n  const applyScrollDeltaRef = useRef((_delta: number) => {});\n\n  applyScrollDeltaRef.current = (delta: number) => {\n    const element = ref.current;\n    if (!element || delta === 0) return;\n    element.scrollTop += delta; // banned-read-ok: preserve the viewport while rows resize.\n    syncRangeFromScrollRef.current();\n  };\n\n  const applyScrollOffset = (\n    offset: number,\n    behavior: VirtualScrollScrollBehaviorOptions[\"behavior\"],\n  ): void => {\n    const element = ref.current;\n    if (!element) return;\n\n    const store = measurementStoreRef.current;\n    const totalSize = dynamicLayout ? store.getTotalSize() : items.length * rowHeight;\n    const clamped = clampScrollOffset(offset, totalSize, viewportHeight);\n    const resolved = resolveScrollBehavior(behavior);\n\n    if (typeof element.scrollTo === \"function\") {\n      element.scrollTo({ top: clamped, behavior: resolved });\n    } else {\n      element.scrollTop = clamped; // banned-read-ok: native scroll fallback for this viewport.\n    }\n    syncRangeFromScrollRef.current();\n\n    if (isSmoothScrollActive(behavior ?? \"auto\", element.scrollTop, clamped)) {\n      // banned-read-ok: poll native smooth-scroll completion.\n      if (smoothRafRef.current !== 0) cancelAnimationFrame(smoothRafRef.current);\n      const tick = (): void => {\n        syncRangeFromScrollRef.current();\n        const node = ref.current;\n        if (!node) {\n          smoothRafRef.current = 0;\n          return;\n        }\n        if (isSmoothScrollActive(\"smooth\", node.scrollTop, clamped)) {\n          // banned-read-ok: poll native smooth-scroll completion.\n          smoothRafRef.current = requestAnimationFrame(tick);\n          return;\n        }\n        smoothRafRef.current = 0;\n      };\n      smoothRafRef.current = requestAnimationFrame(tick);\n    }\n  };\n\n  const applyScrollOffsetRef = useRef(\n    (_offset: number, _behavior: VirtualScrollScrollBehaviorOptions[\"behavior\"]) => {},\n  );\n\n  applyScrollOffsetRef.current = applyScrollOffset;\n\n  useImperativeHandle(\n    scrollRef,\n    (): VirtualScrollHandle => ({\n      get element() {\n        return ref.current;\n      },\n      scrollToIndex(index: number, options?: VirtualScrollScrollToIndexOptions): void {\n        const normalized = normalizeScrollToIndexOptions(options);\n        const store = measurementStoreRef.current;\n        const metrics = {\n          getRowOffset: store.getRowOffset.bind(store),\n          getRowHeight: store.getRowHeight.bind(store),\n          getTotalSize: store.getTotalSize.bind(store),\n        };\n        const offset = computeScrollOffsetForIndex(\n          index,\n          normalized.align,\n          metrics,\n          scrollOptionsRef.current.viewportHeight,\n          scrollTopRef.current,\n        );\n        applyScrollOffsetRef.current(offset, normalized.behavior);\n      },\n      scrollToOffset(offset: number, options?: VirtualScrollScrollBehaviorOptions): void {\n        applyScrollOffsetRef.current(offset, normalizeScrollBehaviorOptions(options));\n      },\n      scrollToEnd(options?: VirtualScrollScrollBehaviorOptions): void {\n        const store = measurementStoreRef.current;\n        const totalSize = dynamicLayout\n          ? store.getTotalSize()\n          : scrollOptionsRef.current.itemCount * scrollOptionsRef.current.rowHeight;\n        const offset = Math.max(0, totalSize - scrollOptionsRef.current.viewportHeight);\n        applyScrollOffsetRef.current(offset, normalizeScrollBehaviorOptions(options));\n      },\n    }),\n    [dynamicLayout],\n  );\n\n  const range = useMemo(() => {\n    void rangeVersion;\n    void measurementVersion;\n    return computeRange();\n  }, [rangeVersion, measurementVersion]);\n\n  const totalSize = useMemo(() => {\n    void measurementVersion;\n    if (dynamicLayout) return measurementStoreRef.current.getTotalSize();\n    return items.length * rowHeight;\n  }, [dynamicLayout, items.length, measurementVersion, rowHeight]);\n\n  const slotCount = useMemo(() => {\n    if (items.length === 0) return 0;\n    return Math.max(\n      range.end - range.start,\n      computeVirtualScrollSlotCount(viewportHeight, rowHeight, overscan),\n    );\n  }, [items.length, overscan, range.end, range.start, rowHeight, viewportHeight]);\n\n  const rowSlots = useMemo(\n    () => buildRowSlots(items, range.start, slotCount),\n    [items, range.start, slotCount],\n  );\n\n  const handleRowMeasureRef = useRef((index: number, itemId: string, height: number) => {\n    const store = measurementStoreRef.current;\n    const previousHeight = store.getRowHeight(index);\n    const rowOffset = store.getRowOffset(index);\n    if (!store.setMeasuredHeight(itemId, index, height)) return;\n\n    const adjustment = computeScrollAdjustmentForRowResize({\n      scrollTop: scrollTopRef.current,\n      rowOffset,\n      previousHeight,\n      nextHeight: height,\n    });\n\n    if (adjustment > 0) {\n      const ios = iosControllerRef.current;\n      if (ios.isTouchScrolling()) {\n        ios.queueAdjustment(adjustment);\n      } else {\n        applyScrollDeltaRef.current(adjustment);\n      }\n    }\n\n    setMeasurementVersion((version) => version + 1);\n  });\n\n  const rowsFragmentRef = useRef<FragmentInstance>(null);\n\n  // One ResizeObserver for the whole pooled row set. React keeps the\n  // subscription in sync as slots mount and unmount — pinned by\n  // core/fragment-instance.test.tsx. Fixed layout never measures rows, so no\n  // observer is created there at all.\n  useEffect(() => {\n    if (!dynamicLayout) return;\n    const fragment = rowsFragmentRef.current;\n    if (!fragment || typeof ResizeObserver === \"undefined\") return;\n\n    const observer = new ResizeObserver((entries) => {\n      for (const entry of entries) {\n        const target = entry.target;\n        if (!(target instanceof HTMLElement)) continue;\n        const raw = target.dataset[\"uiifyRowIndex\"];\n        if (raw === undefined) continue;\n        const index = Number(raw);\n        if (!Number.isInteger(index)) continue;\n        const itemId = itemsRef.current[index]?.id;\n        if (itemId === undefined) continue;\n        handleRowMeasureRef.current(index, itemId, entry.contentRect.height);\n      }\n    });\n\n    fragment.observeUsing(observer);\n    return () => fragment.unobserveUsing(observer);\n  }, [dynamicLayout]);\n\n  useEffect(() => {\n    const element = ref.current;\n    if (!element) return;\n\n    const scrollState = createVirtualScrollScrollState({\n      resetDelay: isScrollingResetDelay,\n      supportsScrollEnd: supportsScrollEndEvent(),\n      onChange: (isScrolling) => {\n        onScrollStateChangeRef.current?.({ isScrolling });\n        if (!isScrolling) {\n          iosControllerRef.current.flushAdjustments(applyScrollDeltaRef.current);\n        }\n      },\n    });\n\n    let onScroll: (() => void) | null = null;\n    let onScrollEnd: (() => void) | null = null;\n    const ios = iosControllerRef.current;\n    const onTouchStart = (): void => ios.onTouchStart();\n    const onTouchEnd = (): void => ios.onTouchEnd();\n\n    onScroll = () => {\n      scrollState.notifyScroll();\n      syncRangeFromScrollRef.current();\n    };\n    element.addEventListener(\"scroll\", onScroll, { passive: true });\n    if (supportsScrollEndEvent()) {\n      onScrollEnd = () => {\n        scrollState.notifyScrollEnd();\n        syncRangeFromScrollRef.current();\n      };\n      element.addEventListener(\"scrollend\", onScrollEnd, { passive: true });\n    }\n    element.addEventListener(\"touchstart\", onTouchStart, { passive: true });\n    element.addEventListener(\"touchend\", onTouchEnd, { passive: true });\n\n    return () => {\n      if (smoothRafRef.current !== 0) cancelAnimationFrame(smoothRafRef.current);\n      if (onScroll) element.removeEventListener(\"scroll\", onScroll);\n      if (onScrollEnd) element.removeEventListener(\"scrollend\", onScrollEnd);\n      element.removeEventListener(\"touchstart\", onTouchStart);\n      element.removeEventListener(\"touchend\", onTouchEnd);\n      scrollState.dispose();\n    };\n  }, [isScrollingResetDelay]);\n\n  useEffect(() => {\n    const element = ref.current;\n    const store = measurementStoreRef.current;\n    const nextTotalSize = dynamicLayout ? store.getTotalSize() : items.length * rowHeight;\n    const previous = anchorSnapshotRef.current;\n    const nextSnapshot = {\n      firstItemId: items[0]?.id,\n      itemCount: items.length,\n      totalSize: nextTotalSize,\n      scrollTop: element?.scrollTop ?? scrollTopRef.current, // banned-read-ok: anchor snapshot reads native position.\n    };\n\n    const adjustment = resolveVirtualScrollAnchorAdjustment({\n      anchor,\n      followAppend,\n      viewportHeight,\n      previous,\n      next: nextSnapshot,\n    });\n\n    if (adjustment && element) {\n      if (adjustment.behavior === \"smooth\" && typeof element.scrollTo === \"function\") {\n        element.scrollTo({\n          top: element.scrollTop + adjustment.delta, // banned-read-ok: retain the anchored viewport.\n          behavior: \"smooth\",\n        });\n      } else {\n        element.scrollTop += adjustment.delta; // banned-read-ok: retain the anchored viewport.\n      }\n      syncRangeFromScrollRef.current();\n    }\n\n    anchorSnapshotRef.current = nextSnapshot;\n  }, [anchor, followAppend, items, dynamicLayout, rowHeight, viewportHeight]);\n\n  useEffect(() => {\n    emitRangeChange(range);\n  }, [range]);\n\n  const scrollportStyle = {\n    height,\n    overflowY: \"auto\",\n    \"--uiify-virtual-scroll-count\": items.length,\n    \"--uiify-virtual-scroll-row-height\": `${rowHeight}px`,\n    ...(dynamicLayout ? { \"--uiify-virtual-scroll-total-size\": `${totalSize}px` } : {}),\n  } as CSSProperties;\n\n  const spacerStyle = dynamicLayout\n    ? undefined\n    : ({\n        \"--uiify-range-start\": range.start,\n      } as CSSProperties);\n\n  return (\n    <div\n      ref={ref}\n      data-testid={testId}\n      data-uiify-virtual-scroll=\"\"\n      data-uiify-dynamic-layout={dynamicLayout ? \"\" : undefined}\n      role={role}\n      className={className}\n      style={scrollportStyle}\n    >\n      <div data-uiify-virtual-scroll-spacer=\"\" style={spacerStyle}>\n        {rowSlots.map((slot) => {\n          const store = measurementStoreRef.current;\n          const rowOffset = dynamicLayout ? store.getRowOffset(slot.index) : undefined;\n          const measuredRowHeight = dynamicLayout ? store.getRowHeight(slot.index) : undefined;\n\n          return (\n            <VirtualScrollRowShell\n              key={`slot-${slot.slotIndex}`}\n              slotIndex={slot.slotIndex}\n              index={slot.index}\n              itemCount={items.length}\n              listRole={role}\n              dynamicLayout={dynamicLayout}\n              {...(rowOffset !== undefined ? { rowOffset } : {})}\n              {...(measuredRowHeight !== undefined ? { rowHeight: measuredRowHeight } : {})}\n            >\n              {slot.item ? (\n                <VirtualScrollRowItem item={slot.item} index={slot.index} renderRow={renderRow} />\n              ) : null}\n            </VirtualScrollRowShell>\n          );\n        })}\n      </div>\n    </div>\n  );\n}\nVirtualScroll.displayName = \"VirtualScroll\";\n"],"mappings":";AAwhBgB;AAthBhB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AACP,SAAS,iBAAiB;AAC1B,SAAS,yBAAyB;AAClC,SAAS,4CAA4C;AACrD;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,oCAAoC;AAS7C,SAAS,4BAA4B;AACrC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,cACP,OACA,YACA,WACoC;AACpC,QAAM,kBAAkB,oCAAoC,MAAM,QAAQ,YAAY,SAAS;AAC/F,SAAO,MAAM,KAAK,EAAE,QAAQ,gBAAgB,GAAG,CAAC,GAAG,cAAc;AAC/D,UAAM,QAAQ,aAAa;AAC3B,WAAO;AAAA,MACL;AAAA,MACA,MAAM,MAAM,KAAK,KAAK;AAAA,MACtB;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAEO,SAAS,cACd,OACc;AACd,QAAM;AAAA,IACJ;AAAA,IACA,SAAS;AAAA,IACT,YAAY;AAAA,IACZ,WAAW;AAAA,IACX;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,SAAS;AAAA,IACT,eAAe;AAAA,IACf;AAAA,IACA,wBAAwB;AAAA,EAC1B,IAAI;AAEJ,QAAM,gBAAgB,sBAAsB;AAC5C,QAAM,MAAM,OAAuB,IAAI;AACvC,QAAM,eAAe,OAAO,CAAC;AAC7B,QAAM,WAAW,OAAO,KAAK;AAC7B,WAAS,UAAU;AACnB,QAAM,eAAe,OAAO,CAAC;AAC7B,QAAM,qBAAqB,OAAe,EAAE;AAC5C,QAAM,qBAAqB,OAAO,oBAAI,IAAoB,CAAC;AAC3D,QAAM,oBAAoB,OAAO;AAAA,IAC/B,aAAa,MAAM,CAAC,GAAG;AAAA,IACvB,WAAW,MAAM;AAAA,IACjB,WAAW;AAAA,IACX,WAAW;AAAA,EACb,CAAC;AAED,QAAM,CAAC,cAAc,eAAe,IAAI,SAAS,CAAC;AAClD,QAAM,CAAC,oBAAoB,qBAAqB,IAAI,SAAS,CAAC;AAE9D,QAAM,eAAe,kBAAkB,GAAG;AAC1C,QAAM,iBAAiB,cAAc,UAAU;AAE/C,QAAM,sBAAsB;AAAA,IAC1B,oCAAoC;AAAA,MAClC,WAAW,MAAM;AAAA,MACjB,kBAAkB;AAAA,MAClB,GAAI,oBAAoB,EAAE,kBAAkB,IAAI,CAAC;AAAA,MACjD,iBAAiB,mBAAmB;AAAA,MACpC,eAAe,CAAC,UAAU,SAAS,QAAQ,KAAK,GAAG;AAAA,IACrD,CAAC;AAAA,EACH;AAEA,sBAAoB,QAAQ,cAAc,MAAM,MAAM;AAEtD,QAAM,mBAAmB,OAAO;AAAA,IAC9B;AAAA,IACA,WAAW,MAAM;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,mBAAiB,UAAU;AAAA,IACzB;AAAA,IACA,WAAW,MAAM;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,QAAM,mBAAmB,OAAO,aAAa;AAC7C,mBAAiB,UAAU;AAE3B,QAAM,yBAAyB,OAAO,mBAAmB;AACzD,yBAAuB,UAAU;AAEjC,QAAM,eAAe,MAAoD;AACvE,UAAM,EAAE,eAAAA,gBAAe,WAAW,UAAAC,WAAU,WAAAC,YAAW,gBAAAC,gBAAe,IACpE,iBAAiB;AACnB,UAAM,YAAY,aAAa;AAE/B,QAAIH,gBAAe;AACjB,YAAM,QAAQ,oBAAoB;AAClC,aAAO,iCAAiC;AAAA,QACtC;AAAA,QACA,gBAAAG;AAAA,QACA;AAAA,QACA,UAAAF;AAAA,QACA,gBAAgB,MAAM;AAAA,QACtB,cAAc,MAAM;AAAA,QACpB,cAAc,MAAM;AAAA,MACtB,CAAC;AAAA,IACH;AAEA,WAAO,0BAA0B;AAAA,MAC/B;AAAA,MACA,gBAAAE;AAAA,MACA;AAAA,MACA,WAAAD;AAAA,MACA,UAAAD;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,kBAAkB,CAACG,WAA8D;AACrF,UAAM,WAAW,iBAAiB;AAClC,QAAI,CAAC,SAAU;AACf,UAAM,UAAU,2BAA2BA,MAAK;AAChD,UAAM,YAAY,GAAG,QAAQ,aAAa,IAAI,QAAQ,WAAW;AACjE,QAAI,cAAc,mBAAmB,QAAS;AAC9C,uBAAmB,UAAU;AAC7B,aAAS,OAAO;AAAA,EAClB;AAEA,QAAM,yBAAyB,OAAO,MAAM;AAAA,EAAC,CAAC;AAE9C,yBAAuB,UAAU,MAAM;AACrC,UAAM,UAAU,IAAI;AACpB,QAAI,CAAC,QAAS;AAEd,UAAM,YAAY,QAAQ;AAC1B,UAAM,gBAAgB,aAAa;AACnC,iBAAa,UAAU;AAEvB,UAAM,YAAY,aAAa;AAC/B,QAAI,YAAY,eAAe,SAAS,EAAG;AAE3C,oBAAgB,SAAS;AAEzB,UAAM,EAAE,eAAAJ,gBAAe,WAAW,gBAAAG,iBAAgB,WAAAD,YAAW,UAAAD,UAAS,IACpE,iBAAiB;AACnB,UAAMI,aAAY;AAAA,MAChB;AAAA,MACA,UAAU;AAAA,MACV,KAAK;AAAA,QACH,UAAU,MAAM,UAAU;AAAA,QAC1B,8BAA8BF,iBAAgBD,YAAWD,SAAQ;AAAA,MACnE;AAAA,IACF;AACA,UAAM,QAAQ,oBAAoB;AAGlC,iCAA6B,SAAS,WAAW;AAAA,MAC/C,eAAAD;AAAA,MACA,WAAAK;AAAA,MACA,cAAc,MAAM,aAAa,KAAK,KAAK;AAAA,IAC7C,CAAC;AAGD,cAAU,MAAM;AACd,sBAAgB,CAAC,YAAY,UAAU,CAAC;AAAA,IAC1C,CAAC;AAAA,EACH;AAEA,QAAM,mBAAmB;AAAA,IACvB,6BAA6B;AAAA,MAC3B,SAAS,6BAA6B;AAAA,MACtC,YAAY;AAAA,IACd,CAAC;AAAA,EACH;AAEA,QAAM,sBAAsB,OAAO,CAAC,WAAmB;AAAA,EAAC,CAAC;AAEzD,sBAAoB,UAAU,CAAC,UAAkB;AAC/C,UAAM,UAAU,IAAI;AACpB,QAAI,CAAC,WAAW,UAAU,EAAG;AAC7B,YAAQ,aAAa;AACrB,2BAAuB,QAAQ;AAAA,EACjC;AAEA,QAAM,oBAAoB,CACxB,QACA,aACS;AACT,UAAM,UAAU,IAAI;AACpB,QAAI,CAAC,QAAS;AAEd,UAAM,QAAQ,oBAAoB;AAClC,UAAMC,aAAY,gBAAgB,MAAM,aAAa,IAAI,MAAM,SAAS;AACxE,UAAM,UAAU,kBAAkB,QAAQA,YAAW,cAAc;AACnE,UAAM,WAAW,sBAAsB,QAAQ;AAE/C,QAAI,OAAO,QAAQ,aAAa,YAAY;AAC1C,cAAQ,SAAS,EAAE,KAAK,SAAS,UAAU,SAAS,CAAC;AAAA,IACvD,OAAO;AACL,cAAQ,YAAY;AAAA,IACtB;AACA,2BAAuB,QAAQ;AAE/B,QAAI,qBAAqB,YAAY,QAAQ,QAAQ,WAAW,OAAO,GAAG;AAExE,UAAI,aAAa,YAAY,EAAG,sBAAqB,aAAa,OAAO;AACzE,YAAM,OAAO,MAAY;AACvB,+BAAuB,QAAQ;AAC/B,cAAM,OAAO,IAAI;AACjB,YAAI,CAAC,MAAM;AACT,uBAAa,UAAU;AACvB;AAAA,QACF;AACA,YAAI,qBAAqB,UAAU,KAAK,WAAW,OAAO,GAAG;AAE3D,uBAAa,UAAU,sBAAsB,IAAI;AACjD;AAAA,QACF;AACA,qBAAa,UAAU;AAAA,MACzB;AACA,mBAAa,UAAU,sBAAsB,IAAI;AAAA,IACnD;AAAA,EACF;AAEA,QAAM,uBAAuB;AAAA,IAC3B,CAAC,SAAiB,cAA8D;AAAA,IAAC;AAAA,EACnF;AAEA,uBAAqB,UAAU;AAE/B;AAAA,IACE;AAAA,IACA,OAA4B;AAAA,MAC1B,IAAI,UAAU;AACZ,eAAO,IAAI;AAAA,MACb;AAAA,MACA,cAAc,OAAe,SAAmD;AAC9E,cAAM,aAAa,8BAA8B,OAAO;AACxD,cAAM,QAAQ,oBAAoB;AAClC,cAAM,UAAU;AAAA,UACd,cAAc,MAAM,aAAa,KAAK,KAAK;AAAA,UAC3C,cAAc,MAAM,aAAa,KAAK,KAAK;AAAA,UAC3C,cAAc,MAAM,aAAa,KAAK,KAAK;AAAA,QAC7C;AACA,cAAM,SAAS;AAAA,UACb;AAAA,UACA,WAAW;AAAA,UACX;AAAA,UACA,iBAAiB,QAAQ;AAAA,UACzB,aAAa;AAAA,QACf;AACA,6BAAqB,QAAQ,QAAQ,WAAW,QAAQ;AAAA,MAC1D;AAAA,MACA,eAAe,QAAgB,SAAoD;AACjF,6BAAqB,QAAQ,QAAQ,+BAA+B,OAAO,CAAC;AAAA,MAC9E;AAAA,MACA,YAAY,SAAoD;AAC9D,cAAM,QAAQ,oBAAoB;AAClC,cAAMA,aAAY,gBACd,MAAM,aAAa,IACnB,iBAAiB,QAAQ,YAAY,iBAAiB,QAAQ;AAClE,cAAM,SAAS,KAAK,IAAI,GAAGA,aAAY,iBAAiB,QAAQ,cAAc;AAC9E,6BAAqB,QAAQ,QAAQ,+BAA+B,OAAO,CAAC;AAAA,MAC9E;AAAA,IACF;AAAA,IACA,CAAC,aAAa;AAAA,EAChB;AAEA,QAAM,QAAQ,QAAQ,MAAM;AAC1B,SAAK;AACL,SAAK;AACL,WAAO,aAAa;AAAA,EACtB,GAAG,CAAC,cAAc,kBAAkB,CAAC;AAErC,QAAM,YAAY,QAAQ,MAAM;AAC9B,SAAK;AACL,QAAI,cAAe,QAAO,oBAAoB,QAAQ,aAAa;AACnE,WAAO,MAAM,SAAS;AAAA,EACxB,GAAG,CAAC,eAAe,MAAM,QAAQ,oBAAoB,SAAS,CAAC;AAE/D,QAAM,YAAY,QAAQ,MAAM;AAC9B,QAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,WAAO,KAAK;AAAA,MACV,MAAM,MAAM,MAAM;AAAA,MAClB,8BAA8B,gBAAgB,WAAW,QAAQ;AAAA,IACnE;AAAA,EACF,GAAG,CAAC,MAAM,QAAQ,UAAU,MAAM,KAAK,MAAM,OAAO,WAAW,cAAc,CAAC;AAE9E,QAAM,WAAW;AAAA,IACf,MAAM,cAAc,OAAO,MAAM,OAAO,SAAS;AAAA,IACjD,CAAC,OAAO,MAAM,OAAO,SAAS;AAAA,EAChC;AAEA,QAAM,sBAAsB,OAAO,CAAC,OAAe,QAAgBC,YAAmB;AACpF,UAAM,QAAQ,oBAAoB;AAClC,UAAM,iBAAiB,MAAM,aAAa,KAAK;AAC/C,UAAM,YAAY,MAAM,aAAa,KAAK;AAC1C,QAAI,CAAC,MAAM,kBAAkB,QAAQ,OAAOA,OAAM,EAAG;AAErD,UAAM,aAAa,oCAAoC;AAAA,MACrD,WAAW,aAAa;AAAA,MACxB;AAAA,MACA;AAAA,MACA,YAAYA;AAAA,IACd,CAAC;AAED,QAAI,aAAa,GAAG;AAClB,YAAM,MAAM,iBAAiB;AAC7B,UAAI,IAAI,iBAAiB,GAAG;AAC1B,YAAI,gBAAgB,UAAU;AAAA,MAChC,OAAO;AACL,4BAAoB,QAAQ,UAAU;AAAA,MACxC;AAAA,IACF;AAEA,0BAAsB,CAAC,YAAY,UAAU,CAAC;AAAA,EAChD,CAAC;AAED,QAAM,kBAAkB,OAAyB,IAAI;AAMrD,YAAU,MAAM;AACd,QAAI,CAAC,cAAe;AACpB,UAAM,WAAW,gBAAgB;AACjC,QAAI,CAAC,YAAY,OAAO,mBAAmB,YAAa;AAExD,UAAM,WAAW,IAAI,eAAe,CAAC,YAAY;AAC/C,iBAAW,SAAS,SAAS;AAC3B,cAAM,SAAS,MAAM;AACrB,YAAI,EAAE,kBAAkB,aAAc;AACtC,cAAM,MAAM,OAAO,QAAQ,eAAe;AAC1C,YAAI,QAAQ,OAAW;AACvB,cAAM,QAAQ,OAAO,GAAG;AACxB,YAAI,CAAC,OAAO,UAAU,KAAK,EAAG;AAC9B,cAAM,SAAS,SAAS,QAAQ,KAAK,GAAG;AACxC,YAAI,WAAW,OAAW;AAC1B,4BAAoB,QAAQ,OAAO,QAAQ,MAAM,YAAY,MAAM;AAAA,MACrE;AAAA,IACF,CAAC;AAED,aAAS,aAAa,QAAQ;AAC9B,WAAO,MAAM,SAAS,eAAe,QAAQ;AAAA,EAC/C,GAAG,CAAC,aAAa,CAAC;AAElB,YAAU,MAAM;AACd,UAAM,UAAU,IAAI;AACpB,QAAI,CAAC,QAAS;AAEd,UAAM,cAAc,+BAA+B;AAAA,MACjD,YAAY;AAAA,MACZ,mBAAmB,uBAAuB;AAAA,MAC1C,UAAU,CAAC,gBAAgB;AACzB,+BAAuB,UAAU,EAAE,YAAY,CAAC;AAChD,YAAI,CAAC,aAAa;AAChB,2BAAiB,QAAQ,iBAAiB,oBAAoB,OAAO;AAAA,QACvE;AAAA,MACF;AAAA,IACF,CAAC;AAED,QAAI,WAAgC;AACpC,QAAI,cAAmC;AACvC,UAAM,MAAM,iBAAiB;AAC7B,UAAM,eAAe,MAAY,IAAI,aAAa;AAClD,UAAM,aAAa,MAAY,IAAI,WAAW;AAE9C,eAAW,MAAM;AACf,kBAAY,aAAa;AACzB,6BAAuB,QAAQ;AAAA,IACjC;AACA,YAAQ,iBAAiB,UAAU,UAAU,EAAE,SAAS,KAAK,CAAC;AAC9D,QAAI,uBAAuB,GAAG;AAC5B,oBAAc,MAAM;AAClB,oBAAY,gBAAgB;AAC5B,+BAAuB,QAAQ;AAAA,MACjC;AACA,cAAQ,iBAAiB,aAAa,aAAa,EAAE,SAAS,KAAK,CAAC;AAAA,IACtE;AACA,YAAQ,iBAAiB,cAAc,cAAc,EAAE,SAAS,KAAK,CAAC;AACtE,YAAQ,iBAAiB,YAAY,YAAY,EAAE,SAAS,KAAK,CAAC;AAElE,WAAO,MAAM;AACX,UAAI,aAAa,YAAY,EAAG,sBAAqB,aAAa,OAAO;AACzE,UAAI,SAAU,SAAQ,oBAAoB,UAAU,QAAQ;AAC5D,UAAI,YAAa,SAAQ,oBAAoB,aAAa,WAAW;AACrE,cAAQ,oBAAoB,cAAc,YAAY;AACtD,cAAQ,oBAAoB,YAAY,UAAU;AAClD,kBAAY,QAAQ;AAAA,IACtB;AAAA,EACF,GAAG,CAAC,qBAAqB,CAAC;AAE1B,YAAU,MAAM;AACd,UAAM,UAAU,IAAI;AACpB,UAAM,QAAQ,oBAAoB;AAClC,UAAM,gBAAgB,gBAAgB,MAAM,aAAa,IAAI,MAAM,SAAS;AAC5E,UAAM,WAAW,kBAAkB;AACnC,UAAM,eAAe;AAAA,MACnB,aAAa,MAAM,CAAC,GAAG;AAAA,MACvB,WAAW,MAAM;AAAA,MACjB,WAAW;AAAA,MACX,WAAW,SAAS,aAAa,aAAa;AAAA;AAAA,IAChD;AAEA,UAAM,aAAa,qCAAqC;AAAA,MACtD;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,IACR,CAAC;AAED,QAAI,cAAc,SAAS;AACzB,UAAI,WAAW,aAAa,YAAY,OAAO,QAAQ,aAAa,YAAY;AAC9E,gBAAQ,SAAS;AAAA,UACf,KAAK,QAAQ,YAAY,WAAW;AAAA;AAAA,UACpC,UAAU;AAAA,QACZ,CAAC;AAAA,MACH,OAAO;AACL,gBAAQ,aAAa,WAAW;AAAA,MAClC;AACA,6BAAuB,QAAQ;AAAA,IACjC;AAEA,sBAAkB,UAAU;AAAA,EAC9B,GAAG,CAAC,QAAQ,cAAc,OAAO,eAAe,WAAW,cAAc,CAAC;AAE1E,YAAU,MAAM;AACd,oBAAgB,KAAK;AAAA,EACvB,GAAG,CAAC,KAAK,CAAC;AAEV,QAAM,kBAAkB;AAAA,IACtB;AAAA,IACA,WAAW;AAAA,IACX,gCAAgC,MAAM;AAAA,IACtC,qCAAqC,GAAG,SAAS;AAAA,IACjD,GAAI,gBAAgB,EAAE,qCAAqC,GAAG,SAAS,KAAK,IAAI,CAAC;AAAA,EACnF;AAEA,QAAM,cAAc,gBAChB,SACC;AAAA,IACC,uBAAuB,MAAM;AAAA,EAC/B;AAEJ,SACE;AAAA,IAAC;AAAA;AAAA,MACC;AAAA,MACA,eAAa;AAAA,MACb,6BAA0B;AAAA,MAC1B,6BAA2B,gBAAgB,KAAK;AAAA,MAChD;AAAA,MACA;AAAA,MACA,OAAO;AAAA,MAEP,8BAAC,SAAI,oCAAiC,IAAG,OAAO,aAC7C,mBAAS,IAAI,CAAC,SAAS;AACtB,cAAM,QAAQ,oBAAoB;AAClC,cAAM,YAAY,gBAAgB,MAAM,aAAa,KAAK,KAAK,IAAI;AACnE,cAAM,oBAAoB,gBAAgB,MAAM,aAAa,KAAK,KAAK,IAAI;AAE3E,eACE;AAAA,UAAC;AAAA;AAAA,YAEC,WAAW,KAAK;AAAA,YAChB,OAAO,KAAK;AAAA,YACZ,WAAW,MAAM;AAAA,YACjB,UAAU;AAAA,YACV;AAAA,YACC,GAAI,cAAc,SAAY,EAAE,UAAU,IAAI,CAAC;AAAA,YAC/C,GAAI,sBAAsB,SAAY,EAAE,WAAW,kBAAkB,IAAI,CAAC;AAAA,YAE1E,eAAK,OACJ,oBAAC,wBAAqB,MAAM,KAAK,MAAM,OAAO,KAAK,OAAO,WAAsB,IAC9E;AAAA;AAAA,UAXC,QAAQ,KAAK,SAAS;AAAA,QAY7B;AAAA,MAEJ,CAAC,GACH;AAAA;AAAA,EACF;AAEJ;AACA,cAAc,cAAc;","names":["dynamicLayout","overscan","rowHeight","viewportHeight","range","slotCount","totalSize","height"]}

package/dist/components/virtual-scroll/VirtualScrollRowItem.d.ts

@@ -0,0 +1,15 @@
+import { type ReactElement, type ReactNode } from "react";
+import type { VirtualScrollItem } from "./types.js";
+export interface VirtualScrollRowItemProps<T extends VirtualScrollItem> {
+    readonly item: T;
+    readonly index: number;
+    readonly renderRow: (item: T, index: number) => ReactNode;
+}
+declare function VirtualScrollRowItemRender<T extends VirtualScrollItem>({ item, index, renderRow, }: VirtualScrollRowItemProps<T>): ReactElement;
+declare namespace VirtualScrollRowItemRender {
+    var displayName: string;
+}
+/** Skips row content re-renders when the pooled slot still shows the same item. */
+export declare const VirtualScrollRowItem: typeof VirtualScrollRowItemRender;
+export {};
+//# sourceMappingURL=VirtualScrollRowItem.d.ts.map

package/dist/components/virtual-scroll/VirtualScrollRowItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualScrollRowItem.d.ts","sourceRoot":"","sources":["../../../src/components/virtual-scroll/VirtualScrollRowItem.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,yBAAyB,CAAC,CAAC,SAAS,iBAAiB;IACpE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC;CAC3D;AAED,iBAAS,0BAA0B,CAAC,CAAC,SAAS,iBAAiB,EAAE,EAC/D,IAAI,EACJ,KAAK,EACL,SAAS,GACV,EAAE,yBAAyB,CAAC,CAAC,CAAC,GAAG,YAAY,CAE7C;kBANQ,0BAA0B;;;AASnC,mFAAmF;AACnF,eAAO,MAAM,oBAAoB,EAM5B,OAAO,0BAA0B,CAAC"}

package/dist/components/virtual-scroll/VirtualScrollRowItem.js

@@ -0,0 +1,18 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { memo } from "react";
+function VirtualScrollRowItemRender({
+  item,
+  index,
+  renderRow
+}) {
+  return /* @__PURE__ */ jsx(Fragment, { children: renderRow(item, index) });
+}
+VirtualScrollRowItemRender.displayName = "VirtualScrollRowItemRender";
+const VirtualScrollRowItem = memo(
+  VirtualScrollRowItemRender,
+  (previous, next) => previous.renderRow === next.renderRow && previous.item.id === next.item.id && previous.index === next.index
+);
+export {
+  VirtualScrollRowItem
+};
+//# sourceMappingURL=VirtualScrollRowItem.js.map

package/dist/components/virtual-scroll/VirtualScrollRowItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/virtual-scroll/VirtualScrollRowItem.tsx"],"sourcesContent":["import { memo, type ReactElement, type ReactNode } from \"react\";\nimport type { VirtualScrollItem } from \"./types.js\";\n\nexport interface VirtualScrollRowItemProps<T extends VirtualScrollItem> {\n  readonly item: T;\n  readonly index: number;\n  readonly renderRow: (item: T, index: number) => ReactNode;\n}\n\nfunction VirtualScrollRowItemRender<T extends VirtualScrollItem>({\n  item,\n  index,\n  renderRow,\n}: VirtualScrollRowItemProps<T>): ReactElement {\n  return <>{renderRow(item, index)}</>;\n}\nVirtualScrollRowItemRender.displayName = \"VirtualScrollRowItemRender\";\n\n/** Skips row content re-renders when the pooled slot still shows the same item. */\nexport const VirtualScrollRowItem = memo(\n  VirtualScrollRowItemRender,\n  (previous, next) =>\n    previous.renderRow === next.renderRow &&\n    previous.item.id === next.item.id &&\n    previous.index === next.index,\n) as typeof VirtualScrollRowItemRender;\n"],"mappings":"AAcS;AAdT,SAAS,YAA+C;AASxD,SAAS,2BAAwD;AAAA,EAC/D;AAAA,EACA;AAAA,EACA;AACF,GAA+C;AAC7C,SAAO,gCAAG,oBAAU,MAAM,KAAK,GAAE;AACnC;AACA,2BAA2B,cAAc;AAGlC,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA,CAAC,UAAU,SACT,SAAS,cAAc,KAAK,aAC5B,SAAS,KAAK,OAAO,KAAK,KAAK,MAC/B,SAAS,UAAU,KAAK;AAC5B;","names":[]}

package/dist/components/virtual-scroll/VirtualScrollRowShell.d.ts

@@ -0,0 +1,29 @@
+import type { ReactElement, ReactNode } from "react";
+import type { VirtualScrollListRole } from "./types.js";
+export declare function computeVirtualScrollSlotCount(viewportHeight: number, rowHeight: number, overscan: number): number;
+/** Clamp pooled slot count so indices never exceed the list tail. */
+export declare function computeActiveVirtualScrollSlotCount(itemCount: number, rangeStart: number, slotCount: number): number;
+interface VirtualScrollRowShellProps {
+    readonly slotIndex: number;
+    readonly index: number;
+    readonly itemCount: number;
+    readonly listRole: VirtualScrollListRole;
+    readonly rowOffset?: number;
+    readonly rowHeight?: number;
+    readonly dynamicLayout: boolean;
+    readonly children: ReactNode;
+}
+/**
+ * Row shell — static `--uiify-slot-index` in fixed mode; per-row offset in dynamic mode.
+ *
+ * Stateless by design: measurement is owned by the single ResizeObserver that
+ * VirtualScroll attaches to the row Fragment, so this component holds no hooks.
+ * `data-uiify-row-index` is how that observer's callback maps an entry back to
+ * a list index.
+ */
+export declare function VirtualScrollRowShell({ slotIndex, index, itemCount, listRole, rowOffset, rowHeight, dynamicLayout, children, }: VirtualScrollRowShellProps): ReactElement;
+export declare namespace VirtualScrollRowShell {
+    var displayName: string;
+}
+export {};
+//# sourceMappingURL=VirtualScrollRowShell.d.ts.map

package/dist/components/virtual-scroll/VirtualScrollRowShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualScrollRowShell.d.ts","sourceRoot":"","sources":["../../../src/components/virtual-scroll/VirtualScrollRowShell.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAiB,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,wBAAgB,6BAA6B,CAC3C,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,MAAM,CAIR;AAED,qEAAqE;AACrE,wBAAgB,mCAAmC,CACjD,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED,UAAU,0BAA0B;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,KAAK,EACL,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,aAAa,EACb,QAAQ,GACT,EAAE,0BAA0B,GAAG,YAAY,CAoB3C;yBA7Be,qBAAqB"}

package/dist/components/virtual-scroll/VirtualScrollRowShell.js

@@ -0,0 +1,47 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+function computeVirtualScrollSlotCount(viewportHeight, rowHeight, overscan) {
+  if (rowHeight <= 0) return 0;
+  const visible = Math.max(1, Math.ceil(viewportHeight / rowHeight));
+  return visible + overscan * 2;
+}
+function computeActiveVirtualScrollSlotCount(itemCount, rangeStart, slotCount) {
+  if (itemCount <= 0 || slotCount <= 0) return 0;
+  return Math.min(slotCount, Math.max(0, itemCount - rangeStart));
+}
+function VirtualScrollRowShell({
+  slotIndex,
+  index,
+  itemCount,
+  listRole,
+  rowOffset,
+  rowHeight,
+  dynamicLayout,
+  children
+}) {
+  const style = {
+    "--uiify-slot-index": slotIndex,
+    ...dynamicLayout && rowOffset !== void 0 ? { "--uiify-row-offset": `${rowOffset}px` } : {},
+    ...dynamicLayout && rowHeight !== void 0 ? { "--uiify-row-height": `${rowHeight}px` } : {}
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-uiify-virtual-scroll-row": "",
+      "data-uiify-row-index": index,
+      "data-uiify-dynamic-row": dynamicLayout ? "" : void 0,
+      role: listRole === "list" ? "listitem" : "row",
+      "aria-setsize": itemCount,
+      "aria-posinset": index + 1,
+      style,
+      children
+    }
+  );
+}
+VirtualScrollRowShell.displayName = "VirtualScrollRowShell";
+export {
+  VirtualScrollRowShell,
+  computeActiveVirtualScrollSlotCount,
+  computeVirtualScrollSlotCount
+};
+//# sourceMappingURL=VirtualScrollRowShell.js.map

package/dist/components/virtual-scroll/VirtualScrollRowShell.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/virtual-scroll/VirtualScrollRowShell.tsx"],"sourcesContent":["\"use client\";\n\nimport type { CSSProperties, ReactElement, ReactNode } from \"react\";\nimport type { VirtualScrollListRole } from \"./types.js\";\n\nexport function computeVirtualScrollSlotCount(\n  viewportHeight: number,\n  rowHeight: number,\n  overscan: number,\n): number {\n  if (rowHeight <= 0) return 0;\n  const visible = Math.max(1, Math.ceil(viewportHeight / rowHeight));\n  return visible + overscan * 2;\n}\n\n/** Clamp pooled slot count so indices never exceed the list tail. */\nexport function computeActiveVirtualScrollSlotCount(\n  itemCount: number,\n  rangeStart: number,\n  slotCount: number,\n): number {\n  if (itemCount <= 0 || slotCount <= 0) return 0;\n  return Math.min(slotCount, Math.max(0, itemCount - rangeStart));\n}\n\ninterface VirtualScrollRowShellProps {\n  readonly slotIndex: number;\n  readonly index: number;\n  readonly itemCount: number;\n  readonly listRole: VirtualScrollListRole;\n  readonly rowOffset?: number;\n  readonly rowHeight?: number;\n  readonly dynamicLayout: boolean;\n  readonly children: ReactNode;\n}\n\n/**\n * Row shell — static `--uiify-slot-index` in fixed mode; per-row offset in dynamic mode.\n *\n * Stateless by design: measurement is owned by the single ResizeObserver that\n * VirtualScroll attaches to the row Fragment, so this component holds no hooks.\n * `data-uiify-row-index` is how that observer's callback maps an entry back to\n * a list index.\n */\nexport function VirtualScrollRowShell({\n  slotIndex,\n  index,\n  itemCount,\n  listRole,\n  rowOffset,\n  rowHeight,\n  dynamicLayout,\n  children,\n}: VirtualScrollRowShellProps): ReactElement {\n  const style = {\n    \"--uiify-slot-index\": slotIndex,\n    ...(dynamicLayout && rowOffset !== undefined ? { \"--uiify-row-offset\": `${rowOffset}px` } : {}),\n    ...(dynamicLayout && rowHeight !== undefined ? { \"--uiify-row-height\": `${rowHeight}px` } : {}),\n  } as CSSProperties;\n\n  return (\n    <div\n      data-uiify-virtual-scroll-row=\"\"\n      data-uiify-row-index={index}\n      data-uiify-dynamic-row={dynamicLayout ? \"\" : undefined}\n      role={listRole === \"list\" ? \"listitem\" : \"row\"}\n      aria-setsize={itemCount}\n      aria-posinset={index + 1}\n      style={style}\n    >\n      {children}\n    </div>\n  );\n}\nVirtualScrollRowShell.displayName = \"VirtualScrollRowShell\";\n"],"mappings":";AA6DI;AAxDG,SAAS,8BACd,gBACA,WACA,UACQ;AACR,MAAI,aAAa,EAAG,QAAO;AAC3B,QAAM,UAAU,KAAK,IAAI,GAAG,KAAK,KAAK,iBAAiB,SAAS,CAAC;AACjE,SAAO,UAAU,WAAW;AAC9B;AAGO,SAAS,oCACd,WACA,YACA,WACQ;AACR,MAAI,aAAa,KAAK,aAAa,EAAG,QAAO;AAC7C,SAAO,KAAK,IAAI,WAAW,KAAK,IAAI,GAAG,YAAY,UAAU,CAAC;AAChE;AAqBO,SAAS,sBAAsB;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAA6C;AAC3C,QAAM,QAAQ;AAAA,IACZ,sBAAsB;AAAA,IACtB,GAAI,iBAAiB,cAAc,SAAY,EAAE,sBAAsB,GAAG,SAAS,KAAK,IAAI,CAAC;AAAA,IAC7F,GAAI,iBAAiB,cAAc,SAAY,EAAE,sBAAsB,GAAG,SAAS,KAAK,IAAI,CAAC;AAAA,EAC/F;AAEA,SACE;AAAA,IAAC;AAAA;AAAA,MACC,iCAA8B;AAAA,MAC9B,wBAAsB;AAAA,MACtB,0BAAwB,gBAAgB,KAAK;AAAA,MAC7C,MAAM,aAAa,SAAS,aAAa;AAAA,MACzC,gBAAc;AAAA,MACd,iBAAe,QAAQ;AAAA,MACvB;AAAA,MAEC;AAAA;AAAA,EACH;AAEJ;AACA,sBAAsB,cAAc;","names":[]}

package/dist/components/virtual-scroll/index.d.ts

@@ -0,0 +1,4 @@
+export { VirtualScroll } from "./VirtualScroll.js";
+export type { VirtualScrollAnchor, VirtualScrollHandle, VirtualScrollItem, VirtualScrollListRole, VirtualScrollOwnProps, VirtualScrollRangeChange, VirtualScrollRowSlot, VirtualScrollScrollAlign, VirtualScrollScrollBehavior, VirtualScrollScrollBehaviorOptions, VirtualScrollScrollState, VirtualScrollScrollToIndexOptions, } from "./types.js";
+export { VIRTUAL_SCROLL_ANCHOR_THRESHOLD, VIRTUAL_SCROLL_OVERSCAN, VIRTUAL_SCROLL_ROW_HEIGHT, VIRTUAL_SCROLL_SCROLL_RESET_DELAY, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/virtual-scroll/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/virtual-scroll/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,kCAAkC,EAClC,wBAAwB,EACxB,iCAAiC,GAClC,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,+BAA+B,EAC/B,uBAAuB,EACvB,yBAAyB,EACzB,iCAAiC,GAClC,MAAM,YAAY,CAAC"}