@vielzeug/virtualit 2.1.0 → 3.0.3

package/dist/virtualit.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"virtualit.cjs","names":[],"sources":["../src/virtualit.ts"],"sourcesContent":["/**\n * @vielzeug/virtualit — Lightweight virtual list / infinite-scroll engine.\n *\n * Framework-agnostic: works with any DOM rendering layer.\n * Uses a `ResizeObserver` to re-measure the scroll container and a\n * `scroll` listener to update the visible window.\n */\n\n// ─── Types ────────────────────────────────────────────────────────────────────\n\nexport interface VirtualItem {\n  /** Original item index in the full list */\n  index: number;\n  /** Pixel offset from the top of the virtual scroll area */\n  top: number;\n  /** Measured (or estimated) pixel height for this item */\n  height: number;\n}\n\nexport interface VirtualizerOptions {\n  /** Total number of items. */\n  count: number;\n  /**\n   * Either a fixed row height or a per-index estimator function.\n   * Defaults to 36px.\n   */\n  estimateSize?: number | ((index: number) => number);\n  /**\n   * Number of items to render outside the visible viewport on each side.\n   * Higher values reduce blank-flash during fast scroll at the cost of more DOM nodes.\n   * Defaults to 3.\n   */\n  overscan?: number;\n  /**\n   * Called whenever the visible range changes. Trigger your re-render here.\n   */\n  onChange?: (items: VirtualItem[], totalSize: number) => void;\n}\n\nexport interface ScrollToIndexOptions {\n  /** 'start' | 'end' | 'center' | 'auto'. Defaults to 'auto'. */\n  align?: 'start' | 'end' | 'center' | 'auto';\n  /** Scroll behaviour. Defaults to 'auto'. */\n  behavior?: ScrollBehavior;\n}\n\nconst DEFAULT_ESTIMATE_SIZE = 36;\nconst DEFAULT_OVERSCAN = 3;\n\nfunction toNonNegativeInt(value: number, fallback = 0): number {\n  if (!Number.isFinite(value)) return fallback;\n\n  return Math.max(0, Math.floor(value));\n}\n\nfunction toPositiveNumber(value: number, fallback: number): number {\n  if (!Number.isFinite(value) || value <= 0) return fallback;\n\n  return value;\n}\n\nfunction createEstimateSizeFn(\n  estimate: number | ((index: number) => number),\n  fallback = DEFAULT_ESTIMATE_SIZE,\n): (index: number) => number {\n  if (typeof estimate === 'number') {\n    const size = toPositiveNumber(estimate, fallback);\n\n    return () => size;\n  }\n\n  return (index: number) => toPositiveNumber(estimate(index), fallback);\n}\n\n// ─── Virtualizer ──────────────────────────────────────────────────────────────\n\nexport class Virtualizer {\n  // mutable options\n  private _count: number;\n  private _estimateSizeFn: (index: number) => number;\n  private overscan: number;\n  private onChange: ((items: VirtualItem[], totalSize: number) => void) | undefined;\n\n  // internal state\n  private measuredHeights: Map<number, number> = new Map();\n  private virtualItems: VirtualItem[] = [];\n  private totalSize = 0;\n  private scrollOffsets: Float64Array = new Float64Array(0); // prefix-sum cache\n  private containerHeight = 0;\n  private scrollTop = 0;\n\n  // render range cache — reset in buildOffsets() so layout changes always re-render\n  private prevRenderStart = -1;\n  private prevRenderEnd = -1;\n\n  // cleanup handles\n  private attachedEl: HTMLElement | null = null;\n  private resizeObserver: ResizeObserver | null = null;\n  private scrollHandler: (() => void) | null = null;\n\n  // batching flag for measureElement\n  private pendingBuild = false;\n\n  constructor(options: VirtualizerOptions) {\n    this._count = toNonNegativeInt(options.count);\n\n    const est = options.estimateSize ?? DEFAULT_ESTIMATE_SIZE;\n\n    this._estimateSizeFn = createEstimateSizeFn(est);\n    this.overscan = toNonNegativeInt(options.overscan ?? DEFAULT_OVERSCAN, DEFAULT_OVERSCAN);\n    this.onChange = options.onChange;\n    // Build the offset table eagerly; computeVisible is deferred to attach()\n    // so the first onChange call always has a real containerHeight.\n    this.buildOffsets();\n  }\n\n  // ─── Public API ───────────────────────────────────────────────────────────\n\n  get count(): number {\n    return this._count;\n  }\n\n  /** Setting count automatically rebuilds offsets and triggers a re-render. */\n  set count(value: number) {\n    const nextCount = toNonNegativeInt(value);\n\n    if (nextCount === this._count) return;\n\n    this._count = nextCount;\n    this.buildOffsets();\n\n    if (this.attachedEl) this.computeVisible();\n  }\n\n  /**\n   * Update the size estimator. Clears all measured heights and re-renders.\n   * Useful when switching between row density modes (e.g. compact ↔ comfortable).\n   */\n  set estimateSize(fn: number | ((index: number) => number)) {\n    this._estimateSizeFn = createEstimateSizeFn(fn);\n    this.measuredHeights.clear();\n    this.buildOffsets();\n\n    if (this.attachedEl) this.computeVisible();\n  }\n\n  /** Start observing the scroll container. */\n  attach(el: HTMLElement): void {\n    this.teardown();\n\n    this.attachedEl = el;\n    this.containerHeight = el.clientHeight;\n    this.scrollTop = el.scrollTop;\n\n    this.scrollHandler = () => {\n      this.scrollTop = el.scrollTop;\n      this.computeVisible();\n    };\n    el.addEventListener('scroll', this.scrollHandler, { passive: true });\n\n    this.resizeObserver = new ResizeObserver(() => {\n      this.containerHeight = el.clientHeight;\n      // The offset table depends only on item heights, not container height —\n      // no need to rebuild it here, only recompute the visible window.\n      this.computeVisible();\n    });\n    this.resizeObserver.observe(el);\n\n    this.computeVisible();\n  }\n\n  /** Stop observing and remove all listeners. */\n  destroy(): void {\n    this.teardown();\n  }\n\n  /** Supports the Explicit Resource Management `using` keyword. */\n  [Symbol.dispose](): void {\n    this.destroy();\n  }\n\n  /** Returns the currently visible virtual items. */\n  getVirtualItems(): VirtualItem[] {\n    return this.virtualItems;\n  }\n\n  /** Total pixel height of the entire list (set as the spacer height). */\n  getTotalSize(): number {\n    return this.totalSize;\n  }\n\n  /**\n   * Record a measured height for a rendered item (for variable-height lists).\n   *\n   * Measurements are batched via microtask — safe to call for every item in a\n   * render loop without incurring O(n²) rebuilds.\n   */\n  measureElement(index: number, height: number): void {\n    const safeIndex = toNonNegativeInt(index, -1);\n    const safeHeight = toPositiveNumber(height, -1);\n\n    if (safeIndex < 0 || safeIndex >= this._count || safeHeight <= 0) return;\n\n    if (this.heightAt(safeIndex) === safeHeight) return;\n\n    this.measuredHeights.set(safeIndex, safeHeight);\n\n    if (!this.pendingBuild) {\n      this.pendingBuild = true;\n      queueMicrotask(() => {\n        this.pendingBuild = false;\n        this.buildOffsets();\n\n        if (this.attachedEl) this.computeVisible();\n      });\n    }\n  }\n\n  /** Programmatically scroll to a specific index. */\n  scrollToIndex(index: number, options: ScrollToIndexOptions = {}): void {\n    const el = this.attachedEl;\n\n    if (!el || this._count <= 0) return;\n\n    const safeIndex = Number.isFinite(index) ? Math.floor(index) : 0;\n    const clampedIndex = Math.max(0, Math.min(safeIndex, this._count - 1));\n    const align = options.align ?? 'auto';\n    const behavior = options.behavior ?? 'auto';\n    const itemTop = this.offsetAt(clampedIndex);\n    const itemHeight = this.heightAt(clampedIndex);\n\n    let targetScrollTop: number;\n\n    if (align === 'start') {\n      targetScrollTop = itemTop;\n    } else if (align === 'end') {\n      targetScrollTop = itemTop + itemHeight - this.containerHeight;\n    } else if (align === 'center') {\n      targetScrollTop = itemTop - (this.containerHeight - itemHeight) / 2;\n    } else {\n      // auto: scroll only if not already visible\n      const visibleStart = el.scrollTop;\n      const visibleEnd = visibleStart + this.containerHeight;\n\n      if (itemTop >= visibleStart && itemTop + itemHeight <= visibleEnd) return;\n\n      targetScrollTop = itemTop < visibleStart ? itemTop : itemTop + itemHeight - this.containerHeight;\n    }\n\n    el.scrollTo({ behavior, top: this.clampScrollTop(targetScrollTop) });\n  }\n\n  /** Programmatically scroll to a specific pixel offset. */\n  scrollToOffset(offset: number, options: { behavior?: ScrollBehavior } = {}): void {\n    this.attachedEl?.scrollTo({\n      behavior: options.behavior ?? 'auto',\n      top: this.clampScrollTop(offset),\n    });\n  }\n\n  /**\n   * Invalidate all item measurements. Call after a font load or layout shift\n   * that changes item heights.\n   */\n  invalidate(): void {\n    this.measuredHeights.clear();\n    this.buildOffsets();\n\n    if (this.attachedEl) this.computeVisible();\n  }\n\n  // ─── Private Helpers ──────────────────────────────────────────────────────\n\n  private teardown(): void {\n    if (this.scrollHandler && this.attachedEl) {\n      this.attachedEl.removeEventListener('scroll', this.scrollHandler);\n      this.scrollHandler = null;\n    }\n\n    this.resizeObserver?.disconnect();\n    this.resizeObserver = null;\n    this.attachedEl = null;\n  }\n\n  private heightAt(index: number): number {\n    return this.measuredHeights.get(index) ?? this._estimateSizeFn(index);\n  }\n\n  private offsetAt(index: number): number {\n    return this.scrollOffsets[index] ?? 0;\n  }\n\n  private clampScrollTop(offset: number): number {\n    const safeOffset = Number.isFinite(offset) ? offset : 0;\n    const maxOffset = Math.max(0, this.totalSize - this.containerHeight);\n\n    return Math.min(maxOffset, Math.max(0, safeOffset));\n  }\n\n  private buildOffsets(): void {\n    // Invalidate the render range cache: item positions may shift even when the\n    // visible index range stays the same (e.g. an item above grew taller).\n    this.prevRenderStart = -1;\n    this.prevRenderEnd = -1;\n\n    const offsets = new Float64Array(this._count + 1);\n\n    offsets[0] = 0;\n    for (let i = 0; i < this._count; i++) {\n      offsets[i + 1] = offsets[i] + this.heightAt(i);\n    }\n    this.scrollOffsets = offsets;\n    this.totalSize = offsets[this._count] ?? 0;\n  }\n\n  private computeVisible(): void {\n    const start = this.scrollTop;\n    const end = start + this.containerHeight;\n\n    // Binary search for the first visible index\n    let lo = 0;\n    let hi = this._count - 1;\n\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1;\n\n      if (this.scrollOffsets[mid + 1] <= start) lo = mid + 1;\n      else hi = mid;\n    }\n\n    const firstVisible = lo;\n\n    // Binary search for the last visible index\n    let lo2 = firstVisible;\n    let hi2 = this._count - 1;\n\n    while (lo2 < hi2) {\n      const mid = (lo2 + hi2 + 1) >> 1;\n\n      if (this.scrollOffsets[mid] < end) lo2 = mid;\n      else hi2 = mid - 1;\n    }\n\n    const lastVisible = lo2;\n    const renderStart = Math.max(0, firstVisible - this.overscan);\n    const renderEnd = Math.min(this._count - 1, lastVisible + this.overscan);\n\n    // Skip re-render when the range is unchanged (e.g. a sub-pixel scroll that\n    // doesn't cross an item boundary). The cache is reset in buildOffsets() so\n    // any layout change always produces at least one render.\n    if (renderStart === this.prevRenderStart && renderEnd === this.prevRenderEnd) return;\n\n    this.prevRenderStart = renderStart;\n    this.prevRenderEnd = renderEnd;\n\n    const items: VirtualItem[] = [];\n\n    for (let i = renderStart; i <= renderEnd; i++) {\n      items.push({ height: this.heightAt(i), index: i, top: this.scrollOffsets[i] });\n    }\n\n    this.virtualItems = items;\n    this.onChange?.(items, this.totalSize);\n  }\n}\n\n// ─── Convenience factory ──────────────────────────────────────────────────────\n\n/**\n * Creates and immediately attaches a `Virtualizer` to the given scroll container.\n *\n * @example\n * ```ts\n * import { createVirtualizer } from '@vielzeug/virtualit';\n *\n * const virt = createVirtualizer(scrollContainerEl, {\n *   count: items.length,\n *   estimateSize: 36,\n *   onChange: (virtualItems, totalSize) => {\n *     // update your rendered list\n *   },\n * });\n *\n * // Later:\n * virt.destroy();\n *\n * // Or, with the Explicit Resource Management proposal:\n * {\n *   using virt = createVirtualizer(scrollContainerEl, { ... });\n * } // virt.destroy() called automatically\n * ```\n */\nexport function createVirtualizer(el: HTMLElement, options: VirtualizerOptions): Virtualizer {\n  const v = new Virtualizer(options);\n\n  v.attach(el);\n\n  return v;\n}\n"],"mappings":"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"}
+{"version":3,"file":"virtualit.cjs","names":[],"sources":["../src/virtualit.ts"],"sourcesContent":["export type VirtualKey = number | string;\n\nexport interface VirtualItem {\n  index: number;\n  start: number;\n  end: number;\n  size: number;\n}\n\nexport type Overscan = { end?: number; start?: number };\n\nexport interface VirtualizerOptions {\n  count: number;\n  estimateSize?: number | ((index: number) => number);\n  gap?: number;\n  getItemKey?: (index: number) => VirtualKey;\n  horizontal?: boolean;\n  initialOffset?: number;\n  onChange?: (items: VirtualItem[], totalSize: number) => void;\n  onScrollEnd?: (offset: number) => void;\n  onScrollingChange?: (isScrolling: boolean) => void;\n  overscan?: Overscan;\n  scrollEndDelay?: number;\n}\n\nexport type VirtualizerUpdateOptions = {\n  count?: number;\n  estimateSize?: number | ((index: number) => number);\n  gap?: number;\n  getItemKey?: (index: number) => VirtualKey;\n  onChange?: (items: VirtualItem[], totalSize: number) => void;\n  onScrollEnd?: (offset: number) => void;\n  onScrollingChange?: (isScrolling: boolean) => void;\n  overscan?: Overscan;\n  scrollEndDelay?: number;\n};\n\nexport interface ScrollToIndexOptions {\n  align?: 'start' | 'end' | 'center' | 'auto';\n  behavior?: ScrollBehavior;\n}\n\nexport interface Virtualizer {\n  readonly count: number;\n  readonly isScrolling: boolean;\n  readonly items: VirtualItem[];\n  readonly scrollOffset: number;\n  readonly totalSize: number;\n  destroy: () => void;\n  invalidate: () => void;\n  measure: (index: number, size: number) => void;\n  refresh: () => void;\n  scrollToIndex: (index: number, options?: ScrollToIndexOptions) => void;\n  scrollToOffset: (offset: number, options?: { behavior?: ScrollBehavior }) => void;\n  update: (next: VirtualizerUpdateOptions) => void;\n  [Symbol.dispose]: () => void;\n}\n\nconst DEFAULT_ESTIMATE_SIZE = 36;\nconst DEFAULT_OVERSCAN = 3;\nconst DEFAULT_SCROLL_END_DELAY = 120;\n\ntype ScrollTarget = HTMLElement | Window;\n\ntype AxisIO = {\n  attach: (onScroll: () => void, onResize: () => void) => () => void;\n  readOffset: () => number;\n  readViewportSize: () => number;\n  writeOffset: (offset: number, behavior: ScrollBehavior) => void;\n};\n\nfunction toNonNegativeInt(value: number, fallback = 0): number {\n  if (!Number.isFinite(value)) return fallback;\n\n  return Math.max(0, Math.floor(value));\n}\n\nfunction toPositiveNumber(value: number, fallback: number): number {\n  if (!Number.isFinite(value) || value <= 0) return fallback;\n\n  return value;\n}\n\nfunction normalizeEstimate(estimate: VirtualizerOptions['estimateSize']): number | ((index: number) => number) {\n  if (typeof estimate === 'number') return toPositiveNumber(estimate, DEFAULT_ESTIMATE_SIZE);\n\n  if (typeof estimate === 'function') return estimate;\n\n  return DEFAULT_ESTIMATE_SIZE;\n}\n\nfunction createEstimateFn(estimate: number | ((index: number) => number)): (index: number) => number {\n  if (typeof estimate === 'number') {\n    return () => estimate;\n  }\n\n  return (index: number) => toPositiveNumber(estimate(index), DEFAULT_ESTIMATE_SIZE);\n}\n\nfunction normalizeOverscan(overscan: Overscan | undefined): { end: number; start: number } {\n  return {\n    end: toNonNegativeInt(overscan?.end ?? DEFAULT_OVERSCAN),\n    start: toNonNegativeInt(overscan?.start ?? DEFAULT_OVERSCAN),\n  };\n}\n\nfunction isWindowTarget(target: ScrollTarget): target is Window {\n  return 'innerHeight' in target && 'innerWidth' in target && !('clientHeight' in target);\n}\n\nfunction createAxisIO(target: ScrollTarget, horizontal: boolean): AxisIO {\n  const isWindow = isWindowTarget(target);\n\n  if (isWindow) {\n    return {\n      attach(onScroll, onResize) {\n        target.addEventListener('scroll', onScroll, { passive: true });\n        target.addEventListener('resize', onResize, { passive: true });\n\n        return () => {\n          target.removeEventListener('scroll', onScroll);\n          target.removeEventListener('resize', onResize);\n        };\n      },\n      readOffset: horizontal ? () => target.scrollX : () => target.scrollY,\n      readViewportSize: horizontal ? () => target.innerWidth : () => target.innerHeight,\n      writeOffset: (offset, behavior) => {\n        target.scrollTo(horizontal ? { behavior, left: offset } : { behavior, top: offset });\n      },\n    };\n  }\n\n  return {\n    attach(onScroll, onResize) {\n      const resizeObserver = new ResizeObserver(onResize);\n\n      target.addEventListener('scroll', onScroll, { passive: true });\n      resizeObserver.observe(target);\n\n      return () => {\n        target.removeEventListener('scroll', onScroll);\n        resizeObserver.disconnect();\n      };\n    },\n    readOffset: horizontal ? () => target.scrollLeft : () => target.scrollTop,\n    readViewportSize: horizontal ? () => target.clientWidth : () => target.clientHeight,\n    writeOffset: (offset, behavior) => {\n      target.scrollTo(horizontal ? { behavior, left: offset } : { behavior, top: offset });\n    },\n  };\n}\n\nexport function createVirtualizer(target: ScrollTarget, options: VirtualizerOptions): Virtualizer {\n  const axis = createAxisIO(target, !!options.horizontal);\n\n  let count = toNonNegativeInt(options.count);\n  let estimateSize = normalizeEstimate(options.estimateSize);\n  let estimateFn = createEstimateFn(estimateSize);\n  let gap = toNonNegativeInt(options.gap ?? 0);\n  let getItemKey = options.getItemKey ?? ((index: number) => index);\n  let overscan = normalizeOverscan(options.overscan);\n  let scrollEndDelay = toNonNegativeInt(options.scrollEndDelay ?? DEFAULT_SCROLL_END_DELAY, DEFAULT_SCROLL_END_DELAY);\n  let onChange = options.onChange;\n  let onScrollEnd = options.onScrollEnd;\n  let onScrollingChange = options.onScrollingChange;\n\n  let items: VirtualItem[] = [];\n  let totalSize = 0;\n  let scrollOffset = 0;\n  let isScrolling = false;\n  const measuredByKey = new Map<VirtualKey, number>();\n  let offsets = new Float64Array(count + 1);\n  let viewportSize = axis.readViewportSize();\n  let prevRenderStart = -1;\n  let prevRenderEnd = -1;\n  let prevTotalSize = -1;\n  let pendingBuild = false;\n  let destroyed = false;\n  let scrollEndTimer: ReturnType<typeof setTimeout> | null = null;\n\n  function keyAt(index: number): VirtualKey {\n    return getItemKey(index);\n  }\n\n  function sizeAt(index: number): number {\n    return measuredByKey.get(keyAt(index)) ?? estimateFn(index);\n  }\n\n  function startAt(index: number): number {\n    return offsets[index] ?? 0;\n  }\n\n  function endAt(index: number): number {\n    return startAt(index) + sizeAt(index);\n  }\n\n  function clampScrollOffset(offset: number): number {\n    const safe = Number.isFinite(offset) ? offset : 0;\n    const maxOffset = Math.max(0, totalSize - viewportSize);\n\n    return Math.min(maxOffset, Math.max(0, safe));\n  }\n\n  function clearScrollEndTimer(): void {\n    if (!scrollEndTimer) return;\n\n    clearTimeout(scrollEndTimer);\n    scrollEndTimer = null;\n  }\n\n  function setScrolling(next: boolean): void {\n    if (isScrolling === next) return;\n\n    isScrolling = next;\n    onScrollingChange?.(next);\n  }\n\n  function scheduleScrollEnd(): void {\n    clearScrollEndTimer();\n\n    scrollEndTimer = setTimeout(() => {\n      scrollEndTimer = null;\n      setScrolling(false);\n      onScrollEnd?.(scrollOffset);\n    }, scrollEndDelay);\n  }\n\n  function onScroll(): void {\n    scrollOffset = clampScrollOffset(axis.readOffset());\n    setScrolling(true);\n    scheduleScrollEnd();\n    computeVisible();\n  }\n\n  function onResize(): void {\n    viewportSize = axis.readViewportSize();\n    computeVisible();\n  }\n\n  function findFirstVisible(offsetStart: number): number {\n    let lo = 0;\n    let hi = count - 1;\n\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1;\n\n      if (endAt(mid) <= offsetStart) lo = mid + 1;\n      else hi = mid;\n    }\n\n    return lo;\n  }\n\n  function findLastVisible(offsetEnd: number, firstVisible: number): number {\n    let lo = firstVisible;\n    let hi = count - 1;\n\n    while (lo < hi) {\n      const mid = (lo + hi + 1) >> 1;\n\n      if (startAt(mid) < offsetEnd) lo = mid;\n      else hi = mid - 1;\n    }\n\n    return lo;\n  }\n\n  function itemFromIndex(index: number): VirtualItem {\n    const start = startAt(index);\n    const size = sizeAt(index);\n\n    return {\n      end: start + size,\n      index,\n      size,\n      start,\n    };\n  }\n\n  function emit(nextItems: VirtualItem[]): void {\n    items = nextItems;\n    onChange?.(nextItems, totalSize);\n  }\n\n  function syncScrollOffset(): void {\n    const rawOffset = axis.readOffset();\n    const nextOffset = clampScrollOffset(rawOffset);\n\n    if (nextOffset === scrollOffset) return;\n\n    scrollOffset = nextOffset;\n\n    if (rawOffset !== nextOffset) axis.writeOffset(nextOffset, 'auto');\n  }\n\n  function rebuildOffsets(): void {\n    prevRenderStart = -1;\n    prevRenderEnd = -1;\n\n    const next = new Float64Array(count + 1);\n\n    for (let i = 0; i < count; i++) {\n      next[i + 1] = next[i] + sizeAt(i) + (i < count - 1 ? gap : 0);\n    }\n\n    offsets = next;\n    totalSize = next[count] ?? 0;\n  }\n\n  function computeVisible(): void {\n    if (destroyed) return;\n\n    syncScrollOffset();\n\n    if (count === 0 || viewportSize <= 0) {\n      if (prevRenderStart !== -1 || prevTotalSize !== totalSize) {\n        prevRenderStart = -1;\n        prevRenderEnd = -1;\n        prevTotalSize = totalSize;\n        emit([]);\n      }\n\n      return;\n    }\n\n    const start = scrollOffset;\n    const end = start + viewportSize;\n    const firstVisible = findFirstVisible(start);\n    const lastVisible = findLastVisible(end, firstVisible);\n    const renderStart = Math.max(0, firstVisible - overscan.start);\n    const renderEnd = Math.min(count - 1, lastVisible + overscan.end);\n\n    if (renderStart === prevRenderStart && renderEnd === prevRenderEnd && prevTotalSize === totalSize) return;\n\n    prevRenderStart = renderStart;\n    prevRenderEnd = renderEnd;\n    prevTotalSize = totalSize;\n\n    const nextItems: VirtualItem[] = [];\n\n    for (let i = renderStart; i <= renderEnd; i++) {\n      nextItems.push(itemFromIndex(i));\n    }\n\n    emit(nextItems);\n  }\n\n  function applyOptions(next: VirtualizerUpdateOptions): void {\n    let needsRebuild = false;\n    let needsCompute = false;\n\n    if ('count' in next && next.count !== undefined) {\n      const nextCount = toNonNegativeInt(next.count);\n\n      if (nextCount !== count) {\n        count = nextCount;\n        needsRebuild = true;\n        needsCompute = true;\n      }\n    }\n\n    if ('estimateSize' in next && next.estimateSize !== undefined) {\n      const normalizedEstimate = normalizeEstimate(next.estimateSize);\n\n      if (normalizedEstimate !== estimateSize) {\n        estimateSize = normalizedEstimate;\n        estimateFn = createEstimateFn(estimateSize);\n        measuredByKey.clear();\n        needsRebuild = true;\n        needsCompute = true;\n      }\n    }\n\n    if ('gap' in next && next.gap !== undefined) {\n      const nextGap = toNonNegativeInt(next.gap);\n\n      if (nextGap !== gap) {\n        gap = nextGap;\n        needsRebuild = true;\n        needsCompute = true;\n      }\n    }\n\n    if ('getItemKey' in next && next.getItemKey) {\n      if (next.getItemKey !== getItemKey) {\n        getItemKey = next.getItemKey;\n        measuredByKey.clear();\n        needsRebuild = true;\n        needsCompute = true;\n      }\n    }\n\n    if ('overscan' in next) {\n      const nextOverscan = normalizeOverscan(next.overscan);\n\n      if (nextOverscan.start !== overscan.start || nextOverscan.end !== overscan.end) {\n        overscan = nextOverscan;\n        needsCompute = true;\n      }\n    }\n\n    if ('scrollEndDelay' in next && next.scrollEndDelay !== undefined) {\n      const nextScrollEndDelay = toNonNegativeInt(next.scrollEndDelay, DEFAULT_SCROLL_END_DELAY);\n\n      if (nextScrollEndDelay !== scrollEndDelay) scrollEndDelay = nextScrollEndDelay;\n    }\n\n    if ('onChange' in next) onChange = next.onChange;\n\n    if ('onScrollEnd' in next) onScrollEnd = next.onScrollEnd;\n\n    if ('onScrollingChange' in next) onScrollingChange = next.onScrollingChange;\n\n    if (needsRebuild) rebuildOffsets();\n\n    if (needsCompute || needsRebuild) computeVisible();\n  }\n\n  function update(next: VirtualizerUpdateOptions): void {\n    if (destroyed) return;\n\n    applyOptions(next);\n  }\n\n  function measure(index: number, size: number): void {\n    if (destroyed) return;\n\n    if (!Number.isFinite(index)) return;\n\n    const safeIndex = Math.floor(index);\n\n    if (safeIndex < 0 || safeIndex >= count) return;\n\n    const safeSize = toPositiveNumber(size, -1);\n\n    if (safeSize <= 0) return;\n\n    const key = keyAt(safeIndex);\n\n    if (measuredByKey.get(key) === safeSize) return;\n\n    measuredByKey.set(key, safeSize);\n\n    if (pendingBuild) return;\n\n    pendingBuild = true;\n    queueMicrotask(() => {\n      pendingBuild = false;\n      rebuildOffsets();\n      computeVisible();\n    });\n  }\n\n  function invalidate(): void {\n    if (destroyed) return;\n\n    measuredByKey.clear();\n    rebuildOffsets();\n    computeVisible();\n  }\n\n  function refresh(): void {\n    if (destroyed) return;\n\n    rebuildOffsets();\n    computeVisible();\n  }\n\n  function scrollToIndex(index: number, options: ScrollToIndexOptions = {}): void {\n    if (destroyed || count <= 0) return;\n\n    const safeIndex = Number.isFinite(index) ? Math.floor(index) : 0;\n    const clampedIndex = Math.max(0, Math.min(safeIndex, count - 1));\n    const align = options.align ?? 'auto';\n    const behavior = options.behavior ?? 'auto';\n    const itemStart = startAt(clampedIndex);\n    const itemSize = sizeAt(clampedIndex);\n    const itemEnd = itemStart + itemSize;\n\n    let targetOffset: number;\n\n    if (align === 'start') {\n      targetOffset = itemStart;\n    } else if (align === 'end') {\n      targetOffset = itemEnd - viewportSize;\n    } else if (align === 'center') {\n      targetOffset = itemStart - (viewportSize - itemSize) / 2;\n    } else {\n      const visibleStart = scrollOffset;\n      const visibleEnd = visibleStart + viewportSize;\n\n      if (itemStart >= visibleStart && itemEnd <= visibleEnd) return;\n\n      targetOffset = itemStart < visibleStart ? itemStart : itemEnd - viewportSize;\n    }\n\n    axis.writeOffset(clampScrollOffset(targetOffset), behavior);\n  }\n\n  function scrollToOffset(offset: number, options: { behavior?: ScrollBehavior } = {}): void {\n    if (destroyed) return;\n\n    axis.writeOffset(clampScrollOffset(offset), options.behavior ?? 'auto');\n  }\n\n  function destroy(): void {\n    if (destroyed) return;\n\n    destroyed = true;\n    clearScrollEndTimer();\n    detachTarget();\n  }\n\n  rebuildOffsets();\n\n  if (options.initialOffset !== undefined) {\n    axis.writeOffset(clampScrollOffset(options.initialOffset), 'auto');\n  }\n\n  scrollOffset = clampScrollOffset(axis.readOffset());\n\n  const detachTarget = axis.attach(onScroll, onResize);\n\n  computeVisible();\n\n  return {\n    get count() {\n      return count;\n    },\n    destroy,\n    invalidate,\n    get isScrolling() {\n      return isScrolling;\n    },\n    get items() {\n      return items;\n    },\n    measure,\n    refresh,\n    get scrollOffset() {\n      return scrollOffset;\n    },\n    scrollToIndex,\n    scrollToOffset,\n    [Symbol.dispose]() {\n      destroy();\n    },\n    get totalSize() {\n      return totalSize;\n    },\n    update,\n  };\n}\n"],"mappings":"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"}

package/dist/virtualit.d.ts

@@ -1,127 +1,60 @@
-/**
- * @vielzeug/virtualit — Lightweight virtual list / infinite-scroll engine.
- *
- * Framework-agnostic: works with any DOM rendering layer.
- * Uses a `ResizeObserver` to re-measure the scroll container and a
- * `scroll` listener to update the visible window.
- */
+export type VirtualKey = number | string;
 export interface VirtualItem {
-    /** Original item index in the full list */
     index: number;
-    /** Pixel offset from the top of the virtual scroll area */
-    top: number;
-    /** Measured (or estimated) pixel height for this item */
-    height: number;
+    start: number;
+    end: number;
+    size: number;
 }
+export type Overscan = {
+    end?: number;
+    start?: number;
+};
 export interface VirtualizerOptions {
-    /** Total number of items. */
     count: number;
-    /**
-     * Either a fixed row height or a per-index estimator function.
-     * Defaults to 36px.
-     */
     estimateSize?: number | ((index: number) => number);
-    /**
-     * Number of items to render outside the visible viewport on each side.
-     * Higher values reduce blank-flash during fast scroll at the cost of more DOM nodes.
-     * Defaults to 3.
-     */
-    overscan?: number;
-    /**
-     * Called whenever the visible range changes. Trigger your re-render here.
-     */
+    gap?: number;
+    getItemKey?: (index: number) => VirtualKey;
+    horizontal?: boolean;
+    initialOffset?: number;
     onChange?: (items: VirtualItem[], totalSize: number) => void;
+    onScrollEnd?: (offset: number) => void;
+    onScrollingChange?: (isScrolling: boolean) => void;
+    overscan?: Overscan;
+    scrollEndDelay?: number;
 }
+export type VirtualizerUpdateOptions = {
+    count?: number;
+    estimateSize?: number | ((index: number) => number);
+    gap?: number;
+    getItemKey?: (index: number) => VirtualKey;
+    onChange?: (items: VirtualItem[], totalSize: number) => void;
+    onScrollEnd?: (offset: number) => void;
+    onScrollingChange?: (isScrolling: boolean) => void;
+    overscan?: Overscan;
+    scrollEndDelay?: number;
+};
 export interface ScrollToIndexOptions {
-    /** 'start' | 'end' | 'center' | 'auto'. Defaults to 'auto'. */
     align?: 'start' | 'end' | 'center' | 'auto';
-    /** Scroll behaviour. Defaults to 'auto'. */
     behavior?: ScrollBehavior;
 }
-export declare class Virtualizer {
-    private _count;
-    private _estimateSizeFn;
-    private overscan;
-    private onChange;
-    private measuredHeights;
-    private virtualItems;
-    private totalSize;
-    private scrollOffsets;
-    private containerHeight;
-    private scrollTop;
-    private prevRenderStart;
-    private prevRenderEnd;
-    private attachedEl;
-    private resizeObserver;
-    private scrollHandler;
-    private pendingBuild;
-    constructor(options: VirtualizerOptions);
-    get count(): number;
-    /** Setting count automatically rebuilds offsets and triggers a re-render. */
-    set count(value: number);
-    /**
-     * Update the size estimator. Clears all measured heights and re-renders.
-     * Useful when switching between row density modes (e.g. compact ↔ comfortable).
-     */
-    set estimateSize(fn: number | ((index: number) => number));
-    /** Start observing the scroll container. */
-    attach(el: HTMLElement): void;
-    /** Stop observing and remove all listeners. */
-    destroy(): void;
-    /** Supports the Explicit Resource Management `using` keyword. */
-    [Symbol.dispose](): void;
-    /** Returns the currently visible virtual items. */
-    getVirtualItems(): VirtualItem[];
-    /** Total pixel height of the entire list (set as the spacer height). */
-    getTotalSize(): number;
-    /**
-     * Record a measured height for a rendered item (for variable-height lists).
-     *
-     * Measurements are batched via microtask — safe to call for every item in a
-     * render loop without incurring O(n²) rebuilds.
-     */
-    measureElement(index: number, height: number): void;
-    /** Programmatically scroll to a specific index. */
-    scrollToIndex(index: number, options?: ScrollToIndexOptions): void;
-    /** Programmatically scroll to a specific pixel offset. */
-    scrollToOffset(offset: number, options?: {
+export interface Virtualizer {
+    readonly count: number;
+    readonly isScrolling: boolean;
+    readonly items: VirtualItem[];
+    readonly scrollOffset: number;
+    readonly totalSize: number;
+    destroy: () => void;
+    invalidate: () => void;
+    measure: (index: number, size: number) => void;
+    refresh: () => void;
+    scrollToIndex: (index: number, options?: ScrollToIndexOptions) => void;
+    scrollToOffset: (offset: number, options?: {
         behavior?: ScrollBehavior;
-    }): void;
-    /**
-     * Invalidate all item measurements. Call after a font load or layout shift
-     * that changes item heights.
-     */
-    invalidate(): void;
-    private teardown;
-    private heightAt;
-    private offsetAt;
-    private clampScrollTop;
-    private buildOffsets;
-    private computeVisible;
+    }) => void;
+    update: (next: VirtualizerUpdateOptions) => void;
+    [Symbol.dispose]: () => void;
 }
-/**
- * Creates and immediately attaches a `Virtualizer` to the given scroll container.
- *
- * @example
- * ```ts
- * import { createVirtualizer } from '@vielzeug/virtualit';
- *
- * const virt = createVirtualizer(scrollContainerEl, {
- *   count: items.length,
- *   estimateSize: 36,
- *   onChange: (virtualItems, totalSize) => {
- *     // update your rendered list
- *   },
- * });
- *
- * // Later:
- * virt.destroy();
- *
- * // Or, with the Explicit Resource Management proposal:
- * {
- *   using virt = createVirtualizer(scrollContainerEl, { ... });
- * } // virt.destroy() called automatically
- * ```
- */
-export declare function createVirtualizer(el: HTMLElement, options: VirtualizerOptions): Virtualizer;
+type ScrollTarget = HTMLElement | Window;
+export declare function createVirtualizer(target: ScrollTarget, options: VirtualizerOptions): Virtualizer;
+export {};
 //# sourceMappingURL=virtualit.d.ts.map

package/dist/virtualit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtualit.d.ts","sourceRoot":"","sources":["../src/virtualit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9D;AAED,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC5C,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAgCD,qBAAa,WAAW;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAkE;IAGlF,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,aAAa,CAAqC;IAC1D,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,SAAS,CAAK;IAGtB,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,aAAa,CAAM;IAG3B,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,aAAa,CAA6B;IAGlD,OAAO,CAAC,YAAY,CAAS;gBAEjB,OAAO,EAAE,kBAAkB;IAevC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,6EAA6E;IAC7E,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,EAStB;IAED;;;OAGG;IACH,IAAI,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,EAMxD;IAED,4CAA4C;IAC5C,MAAM,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAwB7B,+CAA+C;IAC/C,OAAO,IAAI,IAAI;IAIf,iEAAiE;IACjE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;IAIxB,mDAAmD;IACnD,eAAe,IAAI,WAAW,EAAE;IAIhC,wEAAwE;IACxE,YAAY,IAAI,MAAM;IAItB;;;;;OAKG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAqBnD,mDAAmD;IACnD,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,IAAI;IAiCtE,0DAA0D;IAC1D,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,QAAQ,CAAC,EAAE,cAAc,CAAA;KAAO,GAAG,IAAI;IAOjF;;;OAGG;IACH,UAAU,IAAI,IAAI;IASlB,OAAO,CAAC,QAAQ;IAWhB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,cAAc;CAiDvB;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,EAAE,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAM3F"}
+{"version":3,"file":"virtualit.d.ts","sourceRoot":"","sources":["../src/virtualit.ts"],"names":[],"mappings":"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"}

package/dist/virtualit.js

@@ -1,147 +1,244 @@
 //#region src/virtualit.ts
-var e = 36, t = 3;
-function n(e, t = 0) {
+var e = 36, t = 3, n = 120;
+function r(e, t = 0) {
 	return Number.isFinite(e) ? Math.max(0, Math.floor(e)) : t;
 }
-function r(e, t) {
+function i(e, t) {
 	return !Number.isFinite(e) || e <= 0 ? t : e;
 }
-function i(t, n = e) {
-	if (typeof t == "number") {
-		let e = r(t, n);
-		return () => e;
-	}
-	return (e) => r(t(e), n);
+function a(t) {
+	return typeof t == "number" ? i(t, e) : typeof t == "function" ? t : e;
 }
-var a = class {
-	_count;
-	_estimateSizeFn;
-	overscan;
-	onChange;
-	measuredHeights = /* @__PURE__ */ new Map();
-	virtualItems = [];
-	totalSize = 0;
-	scrollOffsets = new Float64Array();
-	containerHeight = 0;
-	scrollTop = 0;
-	prevRenderStart = -1;
-	prevRenderEnd = -1;
-	attachedEl = null;
-	resizeObserver = null;
-	scrollHandler = null;
-	pendingBuild = !1;
-	constructor(r) {
-		this._count = n(r.count), this._estimateSizeFn = i(r.estimateSize ?? e), this.overscan = n(r.overscan ?? t, t), this.onChange = r.onChange, this.buildOffsets();
-	}
-	get count() {
-		return this._count;
-	}
-	set count(e) {
-		let t = n(e);
-		t !== this._count && (this._count = t, this.buildOffsets(), this.attachedEl && this.computeVisible());
-	}
-	set estimateSize(e) {
-		this._estimateSizeFn = i(e), this.measuredHeights.clear(), this.buildOffsets(), this.attachedEl && this.computeVisible();
-	}
-	attach(e) {
-		this.teardown(), this.attachedEl = e, this.containerHeight = e.clientHeight, this.scrollTop = e.scrollTop, this.scrollHandler = () => {
-			this.scrollTop = e.scrollTop, this.computeVisible();
-		}, e.addEventListener("scroll", this.scrollHandler, { passive: !0 }), this.resizeObserver = new ResizeObserver(() => {
-			this.containerHeight = e.clientHeight, this.computeVisible();
-		}), this.resizeObserver.observe(e), this.computeVisible();
-	}
-	destroy() {
-		this.teardown();
-	}
-	[Symbol.dispose]() {
-		this.destroy();
-	}
-	getVirtualItems() {
-		return this.virtualItems;
-	}
-	getTotalSize() {
-		return this.totalSize;
-	}
-	measureElement(e, t) {
-		let i = n(e, -1), a = r(t, -1);
-		i < 0 || i >= this._count || a <= 0 || this.heightAt(i) !== a && (this.measuredHeights.set(i, a), this.pendingBuild || (this.pendingBuild = !0, queueMicrotask(() => {
-			this.pendingBuild = !1, this.buildOffsets(), this.attachedEl && this.computeVisible();
-		})));
-	}
-	scrollToIndex(e, t = {}) {
-		let n = this.attachedEl;
-		if (!n || this._count <= 0) return;
-		let r = Math.max(0, Math.min(Number.isFinite(e) ? Math.floor(e) : 0, this._count - 1)), i = t.align ?? "auto", a = t.behavior ?? "auto", o = this.offsetAt(r), s = this.heightAt(r), c;
-		if (i === "start") c = o;
-		else if (i === "end") c = o + s - this.containerHeight;
-		else if (i === "center") c = o - (this.containerHeight - s) / 2;
-		else {
-			let e = n.scrollTop, t = e + this.containerHeight;
-			if (o >= e && o + s <= t) return;
-			c = o < e ? o : o + s - this.containerHeight;
+function o(t) {
+	return typeof t == "number" ? () => t : (n) => i(t(n), e);
+}
+function s(e) {
+	return {
+		end: r(e?.end ?? t),
+		start: r(e?.start ?? t)
+	};
+}
+function c(e) {
+	return "innerHeight" in e && "innerWidth" in e && !("clientHeight" in e);
+}
+function l(e, t) {
+	return c(e) ? {
+		attach(t, n) {
+			return e.addEventListener("scroll", t, { passive: !0 }), e.addEventListener("resize", n, { passive: !0 }), () => {
+				e.removeEventListener("scroll", t), e.removeEventListener("resize", n);
+			};
+		},
+		readOffset: t ? () => e.scrollX : () => e.scrollY,
+		readViewportSize: t ? () => e.innerWidth : () => e.innerHeight,
+		writeOffset: (n, r) => {
+			e.scrollTo(t ? {
+				behavior: r,
+				left: n
+			} : {
+				behavior: r,
+				top: n
+			});
+		}
+	} : {
+		attach(t, n) {
+			let r = new ResizeObserver(n);
+			return e.addEventListener("scroll", t, { passive: !0 }), r.observe(e), () => {
+				e.removeEventListener("scroll", t), r.disconnect();
+			};
+		},
+		readOffset: t ? () => e.scrollLeft : () => e.scrollTop,
+		readViewportSize: t ? () => e.clientWidth : () => e.clientHeight,
+		writeOffset: (n, r) => {
+			e.scrollTo(t ? {
+				behavior: r,
+				left: n
+			} : {
+				behavior: r,
+				top: n
+			});
 		}
-		n.scrollTo({
-			behavior: a,
-			top: this.clampScrollTop(c)
-		});
+	};
+}
+function u(e, t) {
+	let c = l(e, !!t.horizontal), u = r(t.count), d = a(t.estimateSize), f = o(d), p = r(t.gap ?? 0), m = t.getItemKey ?? ((e) => e), h = s(t.overscan), g = r(t.scrollEndDelay ?? n, n), _ = t.onChange, v = t.onScrollEnd, y = t.onScrollingChange, b = [], x = 0, S = 0, C = !1, w = /* @__PURE__ */ new Map(), T = new Float64Array(u + 1), E = c.readViewportSize(), D = -1, O = -1, k = -1, A = !1, j = !1, M = null;
+	function N(e) {
+		return m(e);
 	}
-	scrollToOffset(e, t = {}) {
-		this.attachedEl?.scrollTo({
-			behavior: t.behavior ?? "auto",
-			top: this.clampScrollTop(e)
-		});
+	function P(e) {
+		return w.get(N(e)) ?? f(e);
 	}
-	invalidate() {
-		this.measuredHeights.clear(), this.buildOffsets(), this.attachedEl && this.computeVisible();
+	function F(e) {
+		return T[e] ?? 0;
 	}
-	teardown() {
-		this.scrollHandler && this.attachedEl && (this.attachedEl.removeEventListener("scroll", this.scrollHandler), this.scrollHandler = null), this.resizeObserver?.disconnect(), this.resizeObserver = null, this.attachedEl = null;
+	function I(e) {
+		return F(e) + P(e);
 	}
-	heightAt(e) {
-		return this.measuredHeights.get(e) ?? this._estimateSizeFn(e);
+	function L(e) {
+		let t = Number.isFinite(e) ? e : 0, n = Math.max(0, x - E);
+		return Math.min(n, Math.max(0, t));
 	}
-	offsetAt(e) {
-		return this.scrollOffsets[e] ?? 0;
+	function R() {
+		M &&= (clearTimeout(M), null);
 	}
-	clampScrollTop(e) {
-		let t = Number.isFinite(e) ? e : 0, n = Math.max(0, this.totalSize - this.containerHeight);
-		return Math.min(n, Math.max(0, t));
+	function z(e) {
+		C !== e && (C = e, y?.(e));
 	}
-	buildOffsets() {
-		this.prevRenderStart = -1, this.prevRenderEnd = -1;
-		let e = new Float64Array(this._count + 1);
-		e[0] = 0;
-		for (let t = 0; t < this._count; t++) e[t + 1] = e[t] + this.heightAt(t);
-		this.scrollOffsets = e, this.totalSize = e[this._count] ?? 0;
+	function B() {
+		R(), M = setTimeout(() => {
+			M = null, z(!1), v?.(S);
+		}, g);
 	}
-	computeVisible() {
-		let e = this.scrollTop, t = e + this.containerHeight, n = 0, r = this._count - 1;
-		for (; n < r;) {
-			let t = n + r >> 1;
-			this.scrollOffsets[t + 1] <= e ? n = t + 1 : r = t;
+	function V() {
+		S = L(c.readOffset()), z(!0), B(), Y();
+	}
+	function H() {
+		E = c.readViewportSize(), Y();
+	}
+	function U(e) {
+		let t = 0, n = u - 1;
+		for (; t < n;) {
+			let r = t + n >> 1;
+			I(r) <= e ? t = r + 1 : n = r;
 		}
-		let i = n, a = i, o = this._count - 1;
-		for (; a < o;) {
-			let e = a + o + 1 >> 1;
-			this.scrollOffsets[e] < t ? a = e : o = e - 1;
+		return t;
+	}
+	function W(e, t) {
+		let n = t, r = u - 1;
+		for (; n < r;) {
+			let t = n + r + 1 >> 1;
+			F(t) < e ? n = t : r = t - 1;
 		}
-		let s = a, c = Math.max(0, i - this.overscan), l = Math.min(this._count - 1, s + this.overscan);
-		if (c === this.prevRenderStart && l === this.prevRenderEnd) return;
-		this.prevRenderStart = c, this.prevRenderEnd = l;
-		let u = [];
-		for (let e = c; e <= l; e++) u.push({
-			height: this.heightAt(e),
+		return n;
+	}
+	function G(e) {
+		let t = F(e), n = P(e);
+		return {
+			end: t + n,
 			index: e,
-			top: this.scrollOffsets[e]
-		});
-		this.virtualItems = u, this.onChange?.(u, this.totalSize);
-	}
-};
-function o(e, t) {
-	let n = new a(t);
-	return n.attach(e), n;
+			size: n,
+			start: t
+		};
+	}
+	function K(e) {
+		b = e, _?.(e, x);
+	}
+	function q() {
+		let e = c.readOffset(), t = L(e);
+		t !== S && (S = t, e !== t && c.writeOffset(t, "auto"));
+	}
+	function J() {
+		D = -1, O = -1;
+		let e = new Float64Array(u + 1);
+		for (let t = 0; t < u; t++) e[t + 1] = e[t] + P(t) + (t < u - 1 ? p : 0);
+		T = e, x = e[u] ?? 0;
+	}
+	function Y() {
+		if (j) return;
+		if (q(), u === 0 || E <= 0) {
+			(D !== -1 || k !== x) && (D = -1, O = -1, k = x, K([]));
+			return;
+		}
+		let e = S, t = e + E, n = U(e), r = W(t, n), i = Math.max(0, n - h.start), a = Math.min(u - 1, r + h.end);
+		if (i === D && a === O && k === x) return;
+		D = i, O = a, k = x;
+		let o = [];
+		for (let e = i; e <= a; e++) o.push(G(e));
+		K(o);
+	}
+	function X(e) {
+		let t = !1, i = !1;
+		if ("count" in e && e.count !== void 0) {
+			let n = r(e.count);
+			n !== u && (u = n, t = !0, i = !0);
+		}
+		if ("estimateSize" in e && e.estimateSize !== void 0) {
+			let n = a(e.estimateSize);
+			n !== d && (d = n, f = o(d), w.clear(), t = !0, i = !0);
+		}
+		if ("gap" in e && e.gap !== void 0) {
+			let n = r(e.gap);
+			n !== p && (p = n, t = !0, i = !0);
+		}
+		if ("getItemKey" in e && e.getItemKey && e.getItemKey !== m && (m = e.getItemKey, w.clear(), t = !0, i = !0), "overscan" in e) {
+			let t = s(e.overscan);
+			(t.start !== h.start || t.end !== h.end) && (h = t, i = !0);
+		}
+		if ("scrollEndDelay" in e && e.scrollEndDelay !== void 0) {
+			let t = r(e.scrollEndDelay, n);
+			t !== g && (g = t);
+		}
+		"onChange" in e && (_ = e.onChange), "onScrollEnd" in e && (v = e.onScrollEnd), "onScrollingChange" in e && (y = e.onScrollingChange), t && J(), (i || t) && Y();
+	}
+	function Z(e) {
+		j || X(e);
+	}
+	function Q(e, t) {
+		if (j || !Number.isFinite(e)) return;
+		let n = Math.floor(e);
+		if (n < 0 || n >= u) return;
+		let r = i(t, -1);
+		if (r <= 0) return;
+		let a = N(n);
+		w.get(a) !== r && (w.set(a, r), !A && (A = !0, queueMicrotask(() => {
+			A = !1, J(), Y();
+		})));
+	}
+	function ee() {
+		j || (w.clear(), J(), Y());
+	}
+	function te() {
+		j || (J(), Y());
+	}
+	function ne(e, t = {}) {
+		if (j || u <= 0) return;
+		let n = Math.max(0, Math.min(Number.isFinite(e) ? Math.floor(e) : 0, u - 1)), r = t.align ?? "auto", i = t.behavior ?? "auto", a = F(n), o = P(n), s = a + o, l;
+		if (r === "start") l = a;
+		else if (r === "end") l = s - E;
+		else if (r === "center") l = a - (E - o) / 2;
+		else {
+			let e = S, t = e + E;
+			if (a >= e && s <= t) return;
+			l = a < e ? a : s - E;
+		}
+		c.writeOffset(L(l), i);
+	}
+	function re(e, t = {}) {
+		j || c.writeOffset(L(e), t.behavior ?? "auto");
+	}
+	function $() {
+		j || (j = !0, R(), ie());
+	}
+	J(), t.initialOffset !== void 0 && c.writeOffset(L(t.initialOffset), "auto"), S = L(c.readOffset());
+	let ie = c.attach(V, H);
+	return Y(), {
+		get count() {
+			return u;
+		},
+		destroy: $,
+		invalidate: ee,
+		get isScrolling() {
+			return C;
+		},
+		get items() {
+			return b;
+		},
+		measure: Q,
+		refresh: te,
+		get scrollOffset() {
+			return S;
+		},
+		scrollToIndex: ne,
+		scrollToOffset: re,
+		[Symbol.dispose]() {
+			$();
+		},
+		get totalSize() {
+			return x;
+		},
+		update: Z
+	};
 }
 //#endregion
-export { a as Virtualizer, o as createVirtualizer };
+export { u as createVirtualizer };
 
 //# sourceMappingURL=virtualit.js.map