{
  "version": 3,
  "sources": ["../src/modules/virtual.js", "../src/modules/events.js", "../src/modules/scroll.js", "../src/modules/dom.js"],
  "sourcesContent": ["// zelvior-runtime/virtual -- windowed (virtualized) list rendering.\n// ESM source of truth; bundled by build.mjs.\n//\n// Why this exists, specifically for weak hardware: a plain DOM list of a\n// few thousand rows costs layout/paint proportional to its full size even\n// when only ~20 rows are ever visible at once -- on a fast machine that's\n// invisible; on a 2009 Atom or a low-end Android WebView it's exactly the\n// kind of thing that turns scrolling into a slideshow. This renders only\n// the visible range (+ a small overscan buffer) and recycles DOM nodes\n// instead of creating/destroying them every frame.\n//\n// The algorithm, stated plainly: for fixed-height items the visible range\n// is O(1) arithmetic (scrollTop / itemHeight). For variable-height items\n// (the common real case -- chat messages, comments, feed posts), finding\n// \"which item is at scroll offset Y\" naively means walking the list\n// summing heights until you pass Y -- O(n) per scroll event, which is\n// exactly the kind of per-frame cost that hurts most on weak CPUs. Instead\n// this maintains a prefix-sum array of cumulative heights and finds the\n// start index via binary search (upper-bound search over a monotonically\n// increasing array) -- O(log n) instead of O(n). For a 5,000-item list\n// that's ~13 comparisons instead of up to 5,000 on every scroll frame.\n\nimport { onScroll } from './scroll.js';\nimport { read, write } from './dom.js';\n\n/**\n * Binary search for the largest index i such that prefix[i] <= y.\n * `prefix` must be sorted ascending (a valid prefix-sum array always is).\n * Exported standalone because \"find the index whose cumulative range\n * contains an offset\" is a genuinely reusable primitive beyond list\n * rendering -- not duplicated logic, the one real place this algorithm\n * lives.\n */\nexport function upperBound(prefix, y) {\n  var lo = 0, hi = prefix.length - 1;\n  while (lo < hi) {\n    var mid = (lo + hi) >>> 1;\n    if (prefix[mid + 1] !== undefined && prefix[mid + 1] <= y) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\n/**\n * Create a virtualized list inside `container` (must have a fixed height\n * and `overflow: auto` / `overflow-y: scroll` set by the caller -- this\n * module doesn't impose styling decisions it doesn't need to).\n *\n * opts.itemCount    - total number of items (can change via setItemCount)\n * opts.itemHeight   - a number (fixed height, O(1) math) OR a function\n *                     (index) => height (variable height, binary search)\n * opts.renderItem   - (index, recycledNode|null) => node. Must return an\n *                     element; if given a recycledNode, may reuse it.\n * opts.recycleItem  - optional (node) => void, called before a node is\n *                     pooled for reuse (e.g. to clear event listeners you\n *                     attached inside renderItem)\n * opts.overscan     - extra items rendered above/below the visible range\n *                     (default 4) so fast scrolling doesn't show blank gaps\n *\n * Returns { refresh, setItemCount, destroy }.\n */\nexport function createVirtualList(opts) {\n  var container = opts.container;\n  var itemCount = opts.itemCount || 0;\n  var renderItem = opts.renderItem;\n  var recycleItem = opts.recycleItem || null;\n  var overscan = opts.overscan != null ? opts.overscan : 4;\n  var fixedHeight = typeof opts.itemHeight === 'number' ? opts.itemHeight : null;\n  var getHeight = typeof opts.itemHeight === 'function' ? opts.itemHeight : function () { return fixedHeight; };\n\n  var prefix = null; // prefix[i] = total height of items [0, i); built lazily, variable-height mode only\n  function buildPrefix() {\n    prefix = new Array(itemCount + 1);\n    prefix[0] = 0;\n    for (var i = 0; i < itemCount; i++) prefix[i + 1] = prefix[i] + getHeight(i);\n  }\n  function totalHeight() {\n    if (fixedHeight != null) return fixedHeight * itemCount;\n    if (!prefix) buildPrefix();\n    return prefix[itemCount];\n  }\n  function indexAtOffset(y) {\n    if (itemCount === 0) return 0;\n    if (fixedHeight != null) return Math.max(0, Math.min(itemCount - 1, Math.floor(y / fixedHeight)));\n    if (!prefix) buildPrefix();\n    return Math.max(0, Math.min(itemCount - 1, upperBound(prefix, y)));\n  }\n  function offsetAtIndex(i) {\n    if (fixedHeight != null) return fixedHeight * i;\n    if (!prefix) buildPrefix();\n    return prefix[i];\n  }\n\n  var spacer = document.createElement('div');\n  spacer.style.position = 'relative';\n  spacer.style.width = '100%';\n  spacer.style.height = totalHeight() + 'px';\n  container.appendChild(spacer);\n\n  var pool = [];\n  var active = new Map(); // index -> node\n\n  function renderRange(startY, endY) {\n    if (itemCount === 0) return;\n    var startIndex = Math.max(0, indexAtOffset(startY) - overscan);\n    var endIndex = Math.min(itemCount - 1, indexAtOffset(endY) + overscan);\n\n    active.forEach(function (node, idx) {\n      if (idx < startIndex || idx > endIndex) {\n        if (recycleItem) recycleItem(node);\n        if (node.parentNode) node.parentNode.removeChild(node);\n        pool.push(node);\n        active.delete(idx);\n      }\n    });\n\n    for (var i = startIndex; i <= endIndex; i++) {\n      if (active.has(i)) continue;\n      var reused = pool.pop() || null;\n      var node = renderItem(i, reused);\n      node.style.position = 'absolute';\n      node.style.top = offsetAtIndex(i) + 'px';\n      node.style.left = '0';\n      node.style.right = '0';\n      if (!node.parentNode) spacer.appendChild(node);\n      active.set(i, node);\n    }\n  }\n\n  function refresh() {\n    read(function () {\n      var startY = container.scrollTop;\n      var endY = startY + container.clientHeight;\n      write(function () { renderRange(startY, endY); });\n    });\n  }\n\n  var unsubscribeScroll = onScroll(container, refresh);\n  refresh();\n\n  return {\n    /** Re-measure and re-render the current visible range (e.g. after container resize). */\n    refresh: refresh,\n    /** Change the total item count (e.g. after loading more data) and re-render. */\n    setItemCount: function (n) {\n      itemCount = n;\n      prefix = null;\n      spacer.style.height = totalHeight() + 'px';\n      refresh();\n    },\n    /** Remove the scroll listener and every rendered node. Call this on teardown. */\n    destroy: function () {\n      unsubscribeScroll();\n      active.forEach(function (node) {\n        if (recycleItem) recycleItem(node);\n        if (node.parentNode) node.parentNode.removeChild(node);\n      });\n      active.clear();\n      pool.length = 0;\n      if (spacer.parentNode) spacer.parentNode.removeChild(spacer);\n    },\n  };\n}\n", "// zelvior-runtime/events -- standalone event helpers.\n// Zero dependency on core zelvior.js by design: importing this module never\n// pulls in the rest of the runtime. ESM source of truth; bundled by build.mjs.\n\nvar hasRaf = typeof window !== 'undefined' && typeof window.requestAnimationFrame === 'function';\nvar hasRic = typeof window !== 'undefined' && typeof window.requestIdleCallback === 'function';\nvar IDLE_SHIM = { timeRemaining: function () { return 8; }, didTimeout: false };\n\n// Feature-detected {passive:true} support. Old Safari (<10) and IE throw a\n// TypeError if addEventListener's 3rd argument is an object at all, so this\n// must probe with a real (immediately-removed) listener rather than assume.\nvar _passiveSupported = null;\nfunction detectPassive() {\n  if (_passiveSupported !== null) return _passiveSupported;\n  _passiveSupported = false;\n  try {\n    var opts = Object.defineProperty({}, 'passive', {\n      get: function () { _passiveSupported = true; return true; }\n    });\n    window.addEventListener('__zelvior_passive_test__', null, opts);\n    window.removeEventListener('__zelvior_passive_test__', null, opts);\n  } catch (e) { _passiveSupported = false; }\n  return _passiveSupported;\n}\n\n/**\n * Feature-detected addEventListener options for a passive listener.\n * Falls back to `false` (bubble phase, non-passive) on browsers that don't\n * support the object form at all, so callers can always spread this in\n * safely: el.addEventListener('scroll', fn, passiveOpts())\n */\nexport function passiveOpts(capture) {\n  if (!detectPassive()) return !!capture;\n  return { passive: true, capture: !!capture };\n}\n\n/**\n * Coalesce rapid calls to at most once per animation frame. Useful for\n * scroll/resize/pointermove handlers where only the latest call in a frame\n * matters. Falls back to a 16ms setTimeout on browsers without rAF.\n * Returns the throttled function; call `.cancel()` on it to drop any\n * pending invocation (e.g. on cleanup).\n */\nexport function throttleRaf(fn) {\n  var scheduled = false;\n  var lastArgs = null;\n  var id = 0;\n  function flush() {\n    scheduled = false;\n    var args = lastArgs;\n    lastArgs = null;\n    fn.apply(null, args || []);\n  }\n  function throttled() {\n    lastArgs = arguments;\n    if (scheduled) return;\n    scheduled = true;\n    id = hasRaf ? requestAnimationFrame(flush) : setTimeout(flush, 16);\n  }\n  throttled.cancel = function () {\n    if (!scheduled) return;\n    if (hasRaf) cancelAnimationFrame(id); else clearTimeout(id);\n    scheduled = false;\n    lastArgs = null;\n  };\n  return throttled;\n}\n\n/**\n * Classic trailing-edge debounce: fn runs `wait` ms after the last call.\n * Distinct from throttleRaf -- this is for \"settled\" events (search-as-you-\n * type, resize-end), not per-frame coalescing.\n * Returns the debounced function; call `.cancel()` to drop a pending call.\n */\nexport function debounce(fn, wait) {\n  var t = 0;\n  function debounced() {\n    var args = arguments;\n    clearTimeout(t);\n    t = setTimeout(function () { fn.apply(null, args); }, wait);\n  }\n  debounced.cancel = function () { clearTimeout(t); };\n  return debounced;\n}\n\n/** requestAnimationFrame with a setTimeout(16) fallback. Returns a cancel function. */\nexport function onFrame(fn) {\n  var id = hasRaf ? requestAnimationFrame(fn) : setTimeout(fn, 16);\n  return function cancel() { hasRaf ? cancelAnimationFrame(id) : clearTimeout(id); };\n}\n\n/** requestIdleCallback with a setTimeout(1) fallback. Returns a cancel function. */\nexport function onIdle(fn, opts) {\n  var id = hasRic\n    ? requestIdleCallback(fn, opts || { timeout: 200 })\n    : setTimeout(function () { fn(IDLE_SHIM); }, 1);\n  return function cancel() { hasRic ? cancelIdleCallback(id) : clearTimeout(id); };\n}\n\n/**\n * Event delegation: one listener on `root` instead of one per matching\n * descendant. Real overhead reduction for lists/tables where attaching a\n * listener to every row/cell would mean hundreds of listeners.\n * `handler` is called as handler(event, matchedElement).\n * Returns an unsubscribe function.\n */\nexport function delegate(root, selector, type, handler, opts) {\n  function onEvent(e) {\n    var el = e.target;\n    while (el && el !== root) {\n      if (el.matches && el.matches(selector)) { handler(e, el); return; }\n      el = el.parentNode;\n    }\n  }\n  root.addEventListener(type, onEvent, opts);\n  return function unsubscribe() { root.removeEventListener(type, onEvent, opts); };\n}\n", "// zelvior-runtime/scroll -- lightweight scroll event helper, plus an\n// opt-in adaptive scroll monitor for feeling smoother/less sticky on\n// weak hardware. ESM source of truth; bundled by build.mjs.\n//\n// `onScroll` intentionally does NOT include a custom scrollbar or replace\n// native scrolling in any way. There is no benchmark evidence that native\n// scrolling needs replacing on any target hardware for this project, and a\n// custom scrollbar is real CSS/DOM/accessibility surface for a browser\n// feature that already performs well. What genuinely has a measurable cost\n// is *listening* to scroll carelessly (a non-passive listener blocks the\n// compositor from scrolling ahead of the main thread; an unthrottled\n// handler can run far more often than once per frame, and mixing DOM reads\n// with writes forces synchronous layout) -- so that's what both `onScroll`\n// and `createAdaptiveScroll` (below) address.\n\nimport { passiveOpts, throttleRaf } from './events.js';\n\n/**\n * Attach a passive, rAF-throttled scroll listener to `target` (defaults to\n * window). `fn` is called at most once per animation frame with\n * `{ x, y, target }`. Returns an unsubscribe function that also cancels any\n * pending throttled call.\n *\n * This does not change how the browser scrolls -- it only ensures your own\n * handler doesn't run more than once per frame and doesn't block the\n * compositor's own scroll handling.\n */\nexport function onScroll(target, fn, opts) {\n  if (typeof target === 'function') { opts = fn; fn = target; target = window; }\n  var capture = opts && opts.capture;\n  var throttled = throttleRaf(function () {\n    var x, y;\n    if (target === window) {\n      x = window.pageXOffset !== undefined ? window.pageXOffset : document.documentElement.scrollLeft;\n      y = window.pageYOffset !== undefined ? window.pageYOffset : document.documentElement.scrollTop;\n    } else {\n      x = target.scrollLeft;\n      y = target.scrollTop;\n    }\n    fn({ x: x, y: y, target: target });\n  });\n  target.addEventListener('scroll', throttled, passiveOpts(capture));\n  return function unsubscribe() {\n    target.removeEventListener('scroll', throttled, passiveOpts(capture));\n    throttled.cancel();\n  };\n}\n\n// --- Adaptive Native Scroll ------------------------------------------------\n//\n// Read this before using it: native compositor-driven scrolling is\n// already about as fast as it gets. This does not make the browser's own\n// scrolling faster, replace it, or add any smoothing/momentum of its own\n// -- doing that would mean re-implementing scroll physics on the main\n// thread, which is slower than the browser's native implementation, not\n// faster. What genuinely causes scrolling to *feel* sticky or janky on\n// weak hardware, and is actually addressable from JS:\n//\n//   1. A non-passive scroll/touch listener blocking the compositor.\n//   2. A scroll handler doing real work (DOM reads/writes) more than\n//      once per frame, or interleaving reads and writes so the browser\n//      is forced into synchronous layout mid-scroll.\n//   3. Scroll-driven work continuing to run its full workload even when\n//      the device is visibly struggling (dropped frames / long tasks\n//      already happening) or the user has asked for reduced motion.\n//\n// `createAdaptiveScroll` addresses exactly those three things, and\n// nothing else. It is entirely event-driven: there is no\n// `setInterval`/permanent polling loop anywhere in this function. A\n// `requestAnimationFrame` is only ever requested in direct response to a\n// real `scroll` event, and the chain stops the moment scrolling settles\n// -- an idle page with this active costs nothing beyond one passive\n// listener sitting there.\nexport function createAdaptiveScroll(fn, opts) {\n  opts = opts || {};\n  var target = opts.target || window;\n  var capture = !!opts.capture;\n  var settleMs = typeof opts.settleMs === 'number' ? opts.settleMs : 150;\n\n  // Device-capability signal, computed once, self-contained -- this\n  // module deliberately does not import zelvior-runtime/tier for this\n  // (an unrelated module pull-in for one cheap check isn't worth the\n  // coupling); it reads the same two real navigator signals tier.js\n  // does, directly. Read via `window.navigator`/`window.matchMedia`\n  // explicitly, not the bare `navigator`/`matchMedia` identifiers --\n  // Node.js itself provides a global `navigator` (since Node 21) that\n  // silently answers with Node's own values instead of throwing, which\n  // is a real, easy-to-hit footgun in any tooling that evaluates this\n  // code outside an actual page (bundler SSR passes, Node-based test\n  // harnesses). Explicitly scoping to `window.*` avoids the ambiguity\n  // entirely rather than relying on the accident of which global wins.\n  var lowEndDevice = false;\n  try {\n    var cores = window.navigator.hardwareConcurrency;\n    var mem = window.navigator.deviceMemory; // Chromium-only; undefined elsewhere, and that's fine below\n    lowEndDevice = (typeof cores === 'number' && cores <= 2) || (typeof mem === 'number' && mem <= 2);\n  } catch (e) {}\n\n  var reducedMotion = false;\n  try { reducedMotion = opts.reducedMotionAware !== false && window.matchMedia('(prefers-reduced-motion: reduce)').matches; } catch (e) {}\n\n  // Long-task/frame-drop awareness, self-contained -- a local\n  // PerformanceObserver, not a pull from any other module. Feature-\n  // detected; simply stays at zero pressure on engines without the\n  // 'longtask' entry type (Safari, most non-Chromium browsers today),\n  // which only means the adaptive throttling below never escalates\n  // beyond its base cadence there -- it does not break anything.\n  var recentLongTasks = 0;\n  var longTaskObserver = null;\n  if (opts.longTaskAware !== false && typeof PerformanceObserver !== 'undefined') {\n    try {\n      if (PerformanceObserver.supportedEntryTypes && PerformanceObserver.supportedEntryTypes.indexOf('longtask') > -1) {\n        longTaskObserver = new PerformanceObserver(function (list) {\n          recentLongTasks += list.getEntries().length;\n        });\n        longTaskObserver.observe({ type: 'longtask', buffered: false });\n      }\n    } catch (e) { longTaskObserver = null; }\n  }\n  // Decays the long-task counter instead of ever fully resetting it on a\n  // fixed timer (which would itself be a small permanent loop) -- it's\n  // decremented lazily, only when a scroll frame actually runs.\n  function decayPressure() { if (recentLongTasks > 0) recentLongTasks--; }\n\n  // FastDOM-style read/write separation, local to this controller so\n  // scroll-time consumers get it without importing zelvior-runtime/paint\n  // (again: no unrelated module pulled in for this). Reads run before\n  // writes within the same already-scheduled frame -- never a separate\n  // frame each, which would just be a second layout-thrashing hazard.\n  var reads = [], writes = [];\n  function flushReadsWrites() {\n    var r = reads; reads = [];\n    var w = writes; writes = [];\n    for (var i = 0; i < r.length; i++) { try { r[i](); } catch (e) {} }\n    for (var j = 0; j < w.length; j++) { try { w[j](); } catch (e) {} }\n  }\n\n  var rafId = null;\n  var frameCounter = 0;\n  var settleTimer = null;\n  var stopped = false;\n\n  function currentPosition() {\n    if (target === window) {\n      return {\n        x: window.pageXOffset !== undefined ? window.pageXOffset : document.documentElement.scrollLeft,\n        y: window.pageYOffset !== undefined ? window.pageYOffset : document.documentElement.scrollTop,\n      };\n    }\n    return { x: target.scrollLeft, y: target.scrollTop };\n  }\n\n  function runFrame() {\n    rafId = null;\n    frameCounter++;\n    decayPressure();\n\n    // Escalating cadence, not a binary on/off: a genuinely struggling\n    // device (recent long tasks piling up) or a low-end/reduced-motion\n    // context runs the consumer callback every other frame instead of\n    // every frame -- still responsive, but roughly half the scroll-time\n    // work. This is \"reduce non-critical work while scrolling is\n    // expensive,\" not \"stop responding to scroll.\"\n    var underPressure = recentLongTasks >= 2 || lowEndDevice || reducedMotion;\n    var shouldRun = !underPressure || (frameCounter % 2 === 0);\n\n    if (shouldRun) {\n      var pos = currentPosition();\n      try {\n        fn({\n          x: pos.x, y: pos.y, target: target,\n          lowEndDevice: lowEndDevice, reducedMotion: reducedMotion, underPressure: underPressure,\n          read: function (r) { reads.push(r); },\n          write: function (w) { writes.push(w); },\n        });\n      } catch (e) {}\n      flushReadsWrites();\n    }\n  }\n\n  function onScrollEvent() {\n    if (stopped) return;\n    if (rafId === null) rafId = requestAnimationFrame(runFrame);\n    if (settleTimer) clearTimeout(settleTimer);\n    settleTimer = setTimeout(function () { settleTimer = null; }, settleMs);\n  }\n\n  target.addEventListener('scroll', onScrollEvent, passiveOpts(capture));\n  // Touch listeners are also registered passive -- this module never\n  // needs to call preventDefault(), so there is no reason not to, and\n  // doing so lets the browser start scrolling without waiting on this\n  // listener at all.\n  var touchTarget = target === window ? window : target;\n  touchTarget.addEventListener('touchmove', function () {}, passiveOpts(capture));\n\n  return {\n    stop: function () {\n      if (stopped) return;\n      stopped = true;\n      target.removeEventListener('scroll', onScrollEvent, passiveOpts(capture));\n      if (rafId !== null) { cancelAnimationFrame(rafId); rafId = null; }\n      if (settleTimer) { clearTimeout(settleTimer); settleTimer = null; }\n      if (longTaskObserver) { longTaskObserver.disconnect(); longTaskObserver = null; }\n      reads = []; writes = [];\n    },\n    isIdle: function () { return rafId === null && settleTimer === null; },\n    isLowEndDevice: function () { return lowEndDevice; },\n    isReducedMotion: function () { return reducedMotion; },\n  };\n}\n", "// zelvior-runtime/dom -- batched DOM read/write scheduling.\n// Zero dependency on core zelvior.js. ESM source of truth; bundled by build.mjs.\n//\n// Real justification (not speculative): interleaved DOM reads and writes\n// from independent call sites force the browser to run layout synchronously\n// between each read, once per interleaving (\"layout thrashing\"). Separating\n// all reads for a frame from all writes for that frame -- the pattern this\n// module implements -- is a well-established fix (see: fastdom, and the\n// \"batch your DOM reads and writes\" guidance in browser rendering-\n// performance documentation). This is the one DOM-performance utility in\n// this runtime with a clear mechanism, not an unverified guess.\n\nvar hasRaf = typeof window !== 'undefined' && typeof window.requestAnimationFrame === 'function';\n\nvar reads = [];\nvar writes = [];\nvar scheduled = false;\nvar nextId = 1;\n\nfunction flush() {\n  scheduled = false;\n  // Snapshot and clear before running -- a read/write scheduled from\n  // inside a callback should land in the *next* frame, not re-enter this\n  // flush and potentially loop.\n  var r = reads; reads = [];\n  var w = writes; writes = [];\n  for (var i = 0; i < r.length; i++) { if (r[i]) safeRun(r[i][1]); }\n  for (var j = 0; j < w.length; j++) { if (w[j]) safeRun(w[j][1]); }\n}\n\nfunction safeRun(fn) {\n  try {\n    fn();\n  } catch (e) {\n    // Reporting the error must never itself be able to abort the flush loop\n    // -- if console.error throws (unusual, but not impossible in some\n    // embedded/sandboxed environments), swallow that too rather than let it\n    // skip every remaining queued callback.\n    try { if (typeof console !== 'undefined' && console.error) console.error(e); } catch (e2) {}\n  }\n}\n\nfunction ensureScheduled() {\n  if (scheduled) return;\n  scheduled = true;\n  if (hasRaf) requestAnimationFrame(flush); else setTimeout(flush, 16);\n}\n\n/**\n * Queue `fn` to run in this frame's read phase (before any write-phase\n * callbacks queued this frame). Use for DOM reads (getBoundingClientRect,\n * offsetWidth, etc.) that would otherwise force a synchronous layout if\n * interleaved with writes elsewhere in the same frame.\n * Returns a numeric id usable with clear().\n */\nexport function read(fn) {\n  var id = nextId++;\n  reads.push([id, fn]);\n  ensureScheduled();\n  return id;\n}\n\n/**\n * Queue `fn` to run in this frame's write phase (after every queued read\n * this frame has run). Use for DOM writes (style/attribute/class changes).\n * Returns a numeric id usable with clear().\n */\nexport function write(fn) {\n  var id = nextId++;\n  writes.push([id, fn]);\n  ensureScheduled();\n  return id;\n}\n\n/** Cancel a previously queued read or write by the id returned from read()/write(). */\nexport function clear(id) {\n  for (var i = 0; i < reads.length; i++) { if (reads[i] && reads[i][0] === id) { reads[i] = null; return; } }\n  for (var j = 0; j < writes.length; j++) { if (writes[j] && writes[j][0] === id) { writes[j] = null; return; } }\n}\n"],
  "mappings": "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",
  "names": ["virtual_exports", "__export", "createVirtualList", "upperBound", "__toCommonJS", "hasRaf", "hasRic", "_passiveSupported", "detectPassive", "opts", "e", "passiveOpts", "capture", "throttleRaf", "fn", "scheduled", "lastArgs", "id", "flush", "args", "throttled", "hasRaf", "onScroll", "target", "fn", "opts", "capture", "throttled", "throttleRaf", "x", "y", "passiveOpts", "hasRaf", "reads", "writes", "scheduled", "nextId", "flush", "r", "w", "i", "safeRun", "j", "fn", "e", "e2", "ensureScheduled", "read", "id", "write", "upperBound", "prefix", "y", "lo", "hi", "mid", "createVirtualList", "opts", "container", "itemCount", "renderItem", "recycleItem", "overscan", "fixedHeight", "getHeight", "buildPrefix", "i", "totalHeight", "indexAtOffset", "offsetAtIndex", "spacer", "pool", "active", "renderRange", "startY", "endY", "startIndex", "endIndex", "node", "idx", "reused", "refresh", "read", "write", "unsubscribeScroll", "onScroll", "n"]
}