react-window 2.3.0 → 2.3.2

package/dist/react-window.js

@@ -1,6 +1,6 @@
 "use client";
-import { jsx as se } from "react/jsx-runtime";
-import { useState as L, useLayoutEffect as ie, useEffect as Z, useMemo as R, useRef as P, useCallback as B, memo as ae, useImperativeHandle as fe, createElement as Q } from "react";
+import { jsx as oe } from "react/jsx-runtime";
+import { useState as V, useLayoutEffect as ce, useEffect as te, useMemo as H, useRef as q, useCallback as $, memo as fe, useImperativeHandle as de, createElement as C } from "react";
 function be(e) {
   let t = e;
   for (; t; ) {
@@ -10,14 +10,14 @@ function be(e) {
   }
   return !1;
 }
-function Ie(e, t) {
-  const [s, r] = L(t === "rtl");
-  return ie(() => {
-    e && (t || r(be(e)));
+function me(e, t) {
+  const [s, r] = V(t === "rtl");
+  return ce(() => {
+    t ? r(t === "rtl") : e && r(be(e));
   }, [t, e]), s;
 }
-const J = typeof window < "u" ? ie : Z;
-function ce(e) {
+const Y = typeof window < "u" ? ce : te;
+function ae(e) {
   if (e !== void 0)
     switch (typeof e) {
       case "number":
@@ -34,92 +34,92 @@ function we({
   defaultHeight: t,
   defaultWidth: s,
   disabled: r,
-  element: n,
-  mode: i,
-  style: l
+  element: o,
+  mode: n,
+  style: a
 }) {
-  const { styleHeight: f, styleWidth: a } = R(
+  const { styleHeight: l, styleWidth: c } = H(
     () => ({
-      styleHeight: ce(l?.height),
-      styleWidth: ce(l?.width)
+      styleHeight: ae(a?.height),
+      styleWidth: ae(a?.width)
     }),
-    [l?.height, l?.width]
-  ), [o, d] = L({
+    [a?.height, a?.width]
+  ), [f, i] = V({
     height: t,
     width: s
-  }), c = r || i === "only-height" && f !== void 0 || i === "only-width" && a !== void 0 || f !== void 0 && a !== void 0;
-  return J(() => {
-    if (n === null || c)
+  }), d = r || n === "only-height" && l !== void 0 || n === "only-width" && c !== void 0 || l !== void 0 && c !== void 0;
+  return Y(() => {
+    if (o === null || d)
       return;
-    const g = new ResizeObserver((x) => {
-      for (const I of x) {
-        const { contentRect: h, target: z } = I;
-        n === z && d((u) => u.height === h.height && u.width === h.width ? u : {
-          height: h.height,
-          width: h.width
+    const u = new ResizeObserver((h) => {
+      for (const x of h) {
+        const { contentRect: p, target: w } = x;
+        o === w && i((g) => g.height === p.height && g.width === p.width ? g : {
+          height: p.height,
+          width: p.width
         });
       }
     });
-    return g.observe(n, { box: e }), () => {
-      g?.unobserve(n);
+    return u.observe(o, { box: e }), () => {
+      u?.unobserve(o);
     };
-  }, [e, c, n, f, a]), R(
+  }, [e, d, o, l, c]), H(
     () => ({
-      height: f ?? o.height,
-      width: a ?? o.width
+      height: l ?? f.height,
+      width: c ?? f.width
     }),
-    [o, f, a]
+    [f, l, c]
   );
 }
-function de(e) {
-  const t = P(() => {
+function ee(e) {
+  const t = q(() => {
     throw new Error("Cannot call an event handler while rendering.");
   });
-  return J(() => {
+  return Y(() => {
     t.current = e;
-  }, [e]), B((...s) => t.current?.(...s), [t]);
+  }, [e]), $((...s) => t.current?.(...s), [t]);
 }
-let F = null;
-function me(e = !1) {
-  if (F === null || e) {
+let N = null;
+function Ie(e = !1) {
+  if (N === null || e) {
     const t = document.createElement("div"), s = t.style;
     s.width = "50px", s.height = "50px", s.overflow = "scroll", s.direction = "rtl";
-    const r = document.createElement("div"), n = r.style;
-    return n.width = "100px", n.height = "100px", t.appendChild(r), document.body.appendChild(t), t.scrollLeft > 0 ? F = "positive-descending" : (t.scrollLeft = 1, t.scrollLeft === 0 ? F = "negative" : F = "positive-ascending"), document.body.removeChild(t), F;
+    const r = document.createElement("div"), o = r.style;
+    return o.width = "100px", o.height = "100px", t.appendChild(r), document.body.appendChild(t), t.scrollLeft > 0 ? N = "positive-descending" : (t.scrollLeft = 1, t.scrollLeft === 0 ? N = "negative" : N = "positive-ascending"), document.body.removeChild(t), N;
   }
-  return F;
+  return N;
 }
-function C({
+function K({
   containerElement: e,
   direction: t,
   isRtl: s,
   scrollOffset: r
 }) {
   if (t === "horizontal" && s)
-    switch (me()) {
+    switch (Ie()) {
       case "negative":
         return -r;
       case "positive-descending": {
         if (e) {
-          const { clientWidth: n, scrollLeft: i, scrollWidth: l } = e;
-          return l - n - i;
+          const { clientWidth: o, scrollWidth: n } = e;
+          return n - o - r;
         }
         break;
       }
     }
   return r;
 }
-function k(e, t = "Assertion error") {
+function L(e, t = "Assertion error") {
   if (!e)
     throw console.error(t), Error(t);
 }
-function X(e, t) {
+function _(e, t) {
   if (e === t)
     return !0;
-  if (!!e != !!t || (k(e !== void 0), k(t !== void 0), Object.keys(e).length !== Object.keys(t).length))
+  if (!!e != !!t || (L(e !== void 0), L(t !== void 0), Object.keys(e).length !== Object.keys(t).length))
     return !1;
   for (const s in e)
-    if (!Object.is(t[s], e[s]))
+    if (!Object.hasOwn(t, s) || !Object.is(t[s], e[s]))
       return !1;
   return !0;
 }
@@ -136,9 +136,9 @@ function ue({
     const r = e.get(
       e.size === 0 ? 0 : e.size - 1
     );
-    k(r !== void 0, "Unexpected bounds cache miss");
-    const n = (r.scrollOffset + r.size) / e.size;
-    return t * n;
+    L(r !== void 0, "Unexpected bounds cache miss");
+    const o = (r.scrollOffset + r.size) / e.size;
+    return t * o;
   }
 }
 function Oe({
@@ -146,123 +146,149 @@ function Oe({
   cachedBounds: t,
   index: s,
   itemCount: r,
-  itemSize: n,
-  containerScrollOffset: i,
-  containerSize: l
+  itemSize: o,
+  containerScrollOffset: n,
+  containerSize: a
 }) {
   if (s < 0 || s >= r)
     throw RangeError(`Invalid index specified: ${s}`, {
       cause: `Index ${s} is not within the range of 0 - ${r - 1}`
     });
-  const f = ue({
+  const l = t.get(s), c = ue({
     cachedBounds: t,
     itemCount: r,
-    itemSize: n
-  }), a = t.get(s), o = Math.max(
+    itemSize: o
+  }), f = Math.max(
     0,
-    Math.min(f - l, a.scrollOffset)
-  ), d = Math.max(
+    Math.min(c - a, l.scrollOffset)
+  ), i = Math.max(
     0,
-    a.scrollOffset - l + a.size
-  );
-  switch (e === "smart" && (i >= d && i <= o ? e = "auto" : e = "center"), e) {
+    l.scrollOffset - a + l.size
+  ), d = l.size > a ? n >= l.scrollOffset && n <= i : n >= i && n <= l.scrollOffset;
+  switch (e === "smart" && (e = d ? "auto" : "center"), e) {
     case "start":
-      return o;
+      return f;
     case "end":
-      return d;
+      return i;
     case "center":
-      return a.scrollOffset <= l / 2 ? 0 : a.scrollOffset + a.size / 2 >= f - l / 2 ? f - l : a.scrollOffset + a.size / 2 - l / 2;
+      return Math.max(
+        0,
+        Math.min(
+          c - a,
+          l.scrollOffset + l.size / 2 - a / 2
+        )
+      );
     case "auto":
     default:
-      return i >= d && i <= o ? i : i < d ? d : o;
+      return d ? n : n < i ? i : f;
   }
 }
-function ee({
+function re({
   cachedBounds: e,
   containerScrollOffset: t,
   containerSize: s,
   itemCount: r,
-  overscanCount: n
+  overscanCount: o
 }) {
-  const i = r - 1;
-  let l = 0, f = -1, a = 0, o = -1, d = 0;
-  for (; d < i; ) {
-    const c = e.get(d);
-    if (c.scrollOffset + c.size > t)
-      break;
-    d++;
-  }
-  for (l = d, a = Math.max(0, l - n); d < i; ) {
-    const c = e.get(d);
-    if (c.scrollOffset + c.size >= t + s)
-      break;
-    d++;
+  const n = r - 1;
+  if (r === 0)
+    return {
+      startIndexVisible: 0,
+      stopIndexVisible: -1,
+      startIndexOverscan: 0,
+      stopIndexOverscan: -1
+    };
+  let a, l;
+  const { itemSize: c } = e;
+  if (c !== void 0 && c > 0)
+    a = Math.max(
+      0,
+      Math.min(n, Math.floor(t / c))
+    ), l = Math.max(
+      a,
+      Math.min(
+        n,
+        Math.ceil((t + s) / c) - 1
+      )
+    );
+  else {
+    let f = 0, i = Math.min(n, Math.max(0, e.size - 1)), d = 1;
+    for (; i < n; ) {
+      const u = e.get(i);
+      if (u.scrollOffset + u.size > t) break;
+      f = i + 1, i = Math.min(n, i + d), d *= 2;
+    }
+    for (; f < i; ) {
+      const u = Math.floor((f + i) / 2), h = e.get(u);
+      h.scrollOffset + h.size > t ? i = u : f = u + 1;
+    }
+    for (a = f, l = f; l < n; ) {
+      const u = e.get(l);
+      if (u.scrollOffset + u.size >= t + s)
+        break;
+      l++;
+    }
   }
-  return f = Math.min(i, d), o = Math.min(r - 1, f + n), l < 0 && (l = 0, f = -1, a = 0, o = -1), {
-    startIndexVisible: l,
-    stopIndexVisible: f,
-    startIndexOverscan: a,
-    stopIndexOverscan: o
+  return {
+    startIndexVisible: a,
+    stopIndexVisible: l,
+    startIndexOverscan: Math.max(0, a - o),
+    stopIndexOverscan: Math.min(n, l + o)
   };
 }
-function ye({
+function ze({
   itemCount: e,
   itemProps: t,
   itemSize: s
 }) {
   const r = /* @__PURE__ */ new Map();
   return {
-    get(n) {
-      for (k(n < e, `Invalid index ${n}`); r.size - 1 < n; ) {
-        const l = r.size;
-        let f;
-        switch (typeof s) {
-          case "function": {
-            f = s(l, t);
-            break;
-          }
-          case "number": {
-            f = s;
-            break;
-          }
-        }
-        if (l === 0)
-          r.set(l, {
-            size: f,
+    itemSize: typeof s == "number" ? s : void 0,
+    get(o) {
+      if (L(o < e, `Invalid index ${o}`), typeof s == "number") {
+        L(o >= 0, `Invalid index ${o}`);
+        let a = r.get(o);
+        return a === void 0 && (a = { size: s, scrollOffset: o * s }, r.set(o, a)), a;
+      }
+      for (; r.size - 1 < o; ) {
+        const a = r.size, l = s(a, t);
+        if (a === 0)
+          r.set(a, {
+            size: l,
             scrollOffset: 0
           });
         else {
-          const a = r.get(l - 1);
-          k(
-            a !== void 0,
-            `Unexpected bounds cache miss for index ${n}`
-          ), r.set(l, {
-            scrollOffset: a.scrollOffset + a.size,
-            size: f
+          const c = r.get(a - 1);
+          L(
+            c !== void 0,
+            `Unexpected bounds cache miss for index ${o}`
+          ), r.set(a, {
+            scrollOffset: c.scrollOffset + c.size,
+            size: l
           });
         }
       }
-      const i = r.get(n);
-      return k(
-        i !== void 0,
-        `Unexpected bounds cache miss for index ${n}`
-      ), i;
+      const n = r.get(o);
+      return L(
+        n !== void 0,
+        `Unexpected bounds cache miss for index ${o}`
+      ), n;
     },
-    set(n, i) {
-      r.set(n, i);
+    set(o, n) {
+      r.set(o, n);
     },
     get size() {
       return r.size;
     }
   };
 }
-function ze({
+function ye({
   itemCount: e,
   itemProps: t,
   itemSize: s
 }) {
-  return R(
-    () => ye({
+  return H(
+    () => ze({
       itemCount: e,
       itemProps: t,
       itemSize: s
@@ -277,13 +303,13 @@ function Se({
   let s;
   switch (typeof t) {
     case "string": {
-      k(
+      L(
         t.endsWith("%"),
         `Invalid item size: "${t}"; string values must be percentages (e.g. "100%")`
-      ), k(
+      ), L(
         e !== void 0,
         "Container size must be defined if a percentage item size is specified"
-      ), s = e * parseInt(t) / 100;
+      ), s = e * parseFloat(t) / 100;
       break;
     }
     default: {
@@ -293,608 +319,710 @@ function Se({
   }
   return s;
 }
-function re({
+function ie({
   containerElement: e,
   containerStyle: t,
   defaultContainerSize: s = 0,
   direction: r,
-  isRtl: n = !1,
-  itemCount: i,
-  itemProps: l,
-  itemSize: f,
-  onResize: a,
-  overscanCount: o
+  isRtl: o = !1,
+  itemCount: n,
+  itemProps: a,
+  itemSize: l,
+  onResize: c,
+  overscanCount: f
 }) {
-  const { height: d = s, width: c = s } = we({
+  const { height: i = s, width: d = s } = we({
     defaultHeight: r === "vertical" ? s : void 0,
     defaultWidth: r === "horizontal" ? s : void 0,
     element: e,
     mode: r === "vertical" ? "only-height" : "only-width",
     style: t
-  }), g = P({
+  }), u = q({
     height: 0,
     width: 0
-  }), x = r === "vertical" ? d : c, I = Se({ containerSize: x, itemSize: f });
-  ie(() => {
-    if (typeof a == "function") {
-      const p = g.current;
-      (p.height !== d || p.width !== c) && (a({ height: d, width: c }, { ...p }), p.height = d, p.width = c);
+  }), h = r === "vertical" ? i : d, x = Se({ containerSize: h, itemSize: l });
+  ce(() => {
+    if (typeof c == "function") {
+      const v = u.current;
+      (v.height !== i || v.width !== d) && (c({ height: i, width: d }, { ...v }), v.height = i, v.width = d);
     }
-  }, [d, a, c]);
-  const h = ze({
-    itemCount: i,
-    itemProps: l,
-    itemSize: I
-  }), z = B(
-    (p) => h.get(p),
-    [h]
-  ), [u, j] = L(
-    () => ee({
-      cachedBounds: h,
+  }, [i, c, d]);
+  const p = ye({
+    itemCount: n,
+    itemProps: a,
+    itemSize: x
+  }), w = $(
+    (v) => p.get(v),
+    [p]
+  ), [g, B] = V(
+    () => re({
+      cachedBounds: p,
       // TODO Potentially support a defaultScrollOffset prop?
       containerScrollOffset: 0,
-      containerSize: x,
-      itemCount: i,
-      overscanCount: o
+      containerSize: h,
+      itemCount: n,
+      overscanCount: f
     })
   ), {
     startIndexVisible: T,
-    startIndexOverscan: E,
-    stopIndexVisible: D,
-    stopIndexOverscan: v
+    startIndexOverscan: M,
+    stopIndexVisible: F,
+    stopIndexOverscan: b
   } = {
-    startIndexVisible: Math.min(i - 1, u.startIndexVisible),
-    startIndexOverscan: Math.min(i - 1, u.startIndexOverscan),
-    stopIndexVisible: Math.min(i - 1, u.stopIndexVisible),
-    stopIndexOverscan: Math.min(i - 1, u.stopIndexOverscan)
-  }, U = B(
+    startIndexVisible: Math.min(n - 1, g.startIndexVisible),
+    startIndexOverscan: Math.min(n - 1, g.startIndexOverscan),
+    stopIndexVisible: Math.min(n - 1, g.stopIndexVisible),
+    stopIndexOverscan: Math.min(n - 1, g.stopIndexOverscan)
+  }, X = $(
     () => ue({
-      cachedBounds: h,
-      itemCount: i,
-      itemSize: I
+      cachedBounds: p,
+      itemCount: n,
+      itemSize: x
     }),
-    [h, i, I]
-  ), m = B(
-    (p) => {
-      const O = C({
+    [p, n, x]
+  ), m = $(
+    (v) => {
+      const I = K({
         containerElement: e,
         direction: r,
-        isRtl: n,
-        scrollOffset: p
+        isRtl: o,
+        scrollOffset: v
       });
-      return ee({
-        cachedBounds: h,
-        containerScrollOffset: O,
-        containerSize: x,
-        itemCount: i,
-        overscanCount: o
+      return re({
+        cachedBounds: p,
+        containerScrollOffset: I,
+        containerSize: h,
+        itemCount: n,
+        overscanCount: f
       });
     },
     [
-      h,
+      p,
       e,
-      x,
+      h,
       r,
+      o,
       n,
-      i,
-      o
+      f
     ]
   );
-  J(() => {
-    const p = (r === "vertical" ? e?.scrollTop : e?.scrollLeft) ?? 0;
-    j(m(p));
-  }, [e, r, m]), J(() => {
+  Y(() => {
+    const v = (r === "vertical" ? e?.scrollTop : e?.scrollLeft) ?? 0;
+    B(m(v));
+  }, [e, r, m]), Y(() => {
     if (!e)
       return;
-    const p = () => {
-      j((O) => {
-        const { scrollLeft: M, scrollTop: S } = e, b = C({
+    const v = () => {
+      B((I) => {
+        const { scrollLeft: R, scrollTop: z } = e, y = K({
           containerElement: e,
           direction: r,
-          isRtl: n,
-          scrollOffset: r === "vertical" ? S : M
-        }), w = ee({
-          cachedBounds: h,
-          containerScrollOffset: b,
-          containerSize: x,
-          itemCount: i,
-          overscanCount: o
+          isRtl: o,
+          scrollOffset: r === "vertical" ? z : R
+        }), G = re({
+          cachedBounds: p,
+          containerScrollOffset: y,
+          containerSize: h,
+          itemCount: n,
+          overscanCount: f
         });
-        return X(w, O) ? O : w;
+        return _(G, I) ? I : G;
       });
     };
-    return e.addEventListener("scroll", p), () => {
-      e.removeEventListener("scroll", p);
+    return e.addEventListener("scroll", v), () => {
+      e.removeEventListener("scroll", v);
     };
   }, [
-    h,
+    p,
     e,
-    x,
+    h,
     r,
-    i,
-    o
+    o,
+    n,
+    f
   ]);
-  const G = de(
+  const U = ee(
     ({
-      align: p = "auto",
-      containerScrollOffset: O,
-      index: M
+      align: v = "auto",
+      containerScrollOffset: I,
+      index: R
     }) => {
-      let S = Oe({
-        align: p,
-        cachedBounds: h,
-        containerScrollOffset: O,
-        containerSize: x,
-        index: M,
-        itemCount: i,
-        itemSize: I
+      let z = Oe({
+        align: v,
+        cachedBounds: p,
+        containerScrollOffset: K({
+          containerElement: e,
+          direction: r,
+          isRtl: o,
+          scrollOffset: I
+        }),
+        containerSize: h,
+        index: R,
+        itemCount: n,
+        itemSize: x
       });
       if (e) {
-        if (S = C({
+        if (z = K({
           containerElement: e,
           direction: r,
-          isRtl: n,
-          scrollOffset: S
+          isRtl: o,
+          scrollOffset: z
         }), typeof e.scrollTo != "function") {
-          const b = m(S);
-          X(u, b) || j(b);
+          const y = m(z);
+          _(g, y) || B(y);
         }
-        return S;
+        return z;
       }
     }
   );
   return {
-    getCellBounds: z,
-    getEstimatedSize: U,
-    scrollToIndex: G,
-    startIndexOverscan: E,
+    getCellBounds: w,
+    getEstimatedSize: X,
+    scrollToIndex: U,
+    startIndexOverscan: M,
     startIndexVisible: T,
-    stopIndexOverscan: v,
-    stopIndexVisible: D
+    stopIndexOverscan: b,
+    stopIndexVisible: F
   };
 }
 function he(e) {
-  return R(() => e, Object.values(e));
+  const [t, s] = V(e);
+  return _(t, e) ? t : (s(e), e);
 }
 function pe(e, t) {
   const {
     ariaAttributes: s,
     style: r,
-    ...n
+    ...o
   } = e, {
-    ariaAttributes: i,
-    style: l,
-    ...f
+    ariaAttributes: n,
+    style: a,
+    ...l
   } = t;
-  return X(s, i) && X(r, l) && X(n, f);
+  return _(s, n) && _(r, a) && _(o, l);
 }
-function Ve({
+function Le({
   cellComponent: e,
   cellProps: t,
   children: s,
   className: r,
-  columnCount: n,
-  columnKey: i,
-  columnWidth: l,
-  defaultHeight: f = 0,
-  defaultWidth: a = 0,
-  dir: o,
-  gridRef: d,
-  onCellsRendered: c,
-  onResize: g,
-  overscanCount: x = 3,
-  rowCount: I,
-  rowHeight: h,
-  rowKey: z,
-  style: u,
-  tagName: j = "div",
+  columnCount: o,
+  columnKey: n,
+  columnWidth: a,
+  defaultHeight: l = 0,
+  defaultWidth: c = 0,
+  dir: f,
+  gridRef: i,
+  onCellsRendered: d,
+  onResize: u,
+  overscanCount: h = 3,
+  rowCount: x,
+  rowHeight: p,
+  rowKey: w,
+  style: g,
+  tagName: B = "div",
   ...T
 }) {
-  const E = he(t), D = R(
-    () => ae(e, pe),
+  const M = he(t), F = H(
+    () => fe(e, pe),
     [e]
-  ), [v, U] = L(null), m = Ie(v, o), {
-    getCellBounds: G,
-    getEstimatedSize: p,
-    startIndexOverscan: O,
-    startIndexVisible: M,
-    scrollToIndex: S,
-    stopIndexOverscan: b,
-    stopIndexVisible: w
-  } = re({
-    containerElement: v,
-    containerStyle: u,
-    defaultContainerSize: a,
+  ), [b, X] = V(null), m = me(b, f), {
+    getCellBounds: U,
+    getEstimatedSize: v,
+    startIndexOverscan: I,
+    startIndexVisible: R,
+    scrollToIndex: z,
+    stopIndexOverscan: y,
+    stopIndexVisible: G
+  } = ie({
+    containerElement: b,
+    containerStyle: g,
+    defaultContainerSize: c,
     direction: "horizontal",
     isRtl: m,
-    itemCount: n,
-    itemProps: E,
-    itemSize: l,
-    onResize: g,
-    overscanCount: x
+    itemCount: o,
+    itemProps: M,
+    itemSize: a,
+    onResize: u,
+    overscanCount: h
   }), {
-    getCellBounds: V,
-    getEstimatedSize: _,
-    startIndexOverscan: N,
-    startIndexVisible: oe,
-    scrollToIndex: K,
-    stopIndexOverscan: Y,
+    getCellBounds: E,
+    getEstimatedSize: S,
+    startIndexOverscan: A,
+    startIndexVisible: P,
+    scrollToIndex: se,
+    stopIndexOverscan: J,
     stopIndexVisible: le
-  } = re({
-    containerElement: v,
-    containerStyle: u,
-    defaultContainerSize: f,
+  } = ie({
+    containerElement: b,
+    containerStyle: g,
+    defaultContainerSize: l,
     direction: "vertical",
-    itemCount: I,
-    itemProps: E,
-    itemSize: h,
-    onResize: g,
-    overscanCount: x
+    itemCount: x,
+    itemProps: M,
+    itemSize: p,
+    onResize: u,
+    overscanCount: h
   });
-  fe(
-    d,
+  de(
+    i,
     () => ({
       get element() {
-        return v;
+        return b;
       },
       scrollToCell({
-        behavior: $ = "auto",
-        columnAlign: y = "auto",
-        columnIndex: H,
-        rowAlign: W = "auto",
-        rowIndex: A
+        behavior: W = "auto",
+        columnAlign: O = "auto",
+        columnIndex: j,
+        rowAlign: D = "auto",
+        rowIndex: k
       }) {
-        const q = S({
-          align: y,
-          containerScrollOffset: v?.scrollLeft ?? 0,
-          index: H
-        }), ve = K({
-          align: W,
-          containerScrollOffset: v?.scrollTop ?? 0,
-          index: A
+        const Q = z({
+          align: O,
+          containerScrollOffset: b?.scrollLeft ?? 0,
+          index: j
+        }), xe = se({
+          align: D,
+          containerScrollOffset: b?.scrollTop ?? 0,
+          index: k
         });
-        typeof v?.scrollTo == "function" && v.scrollTo({
-          behavior: $,
-          left: q,
-          top: ve
+        typeof b?.scrollTo == "function" && b.scrollTo({
+          behavior: W,
+          left: Q,
+          top: xe
         });
       },
       scrollToColumn({
-        align: $ = "auto",
-        behavior: y = "auto",
-        index: H
+        align: W = "auto",
+        behavior: O = "auto",
+        index: j
       }) {
-        const W = S({
-          align: $,
-          containerScrollOffset: v?.scrollLeft ?? 0,
-          index: H
+        const D = z({
+          align: W,
+          containerScrollOffset: b?.scrollLeft ?? 0,
+          index: j
         });
-        typeof v?.scrollTo == "function" && v.scrollTo({
-          behavior: y,
-          left: W
+        typeof b?.scrollTo == "function" && b.scrollTo({
+          behavior: O,
+          left: D
         });
       },
       scrollToRow({
-        align: $ = "auto",
-        behavior: y = "auto",
-        index: H
+        align: W = "auto",
+        behavior: O = "auto",
+        index: j
       }) {
-        const W = K({
-          align: $,
-          containerScrollOffset: v?.scrollTop ?? 0,
-          index: H
+        const D = se({
+          align: W,
+          containerScrollOffset: b?.scrollTop ?? 0,
+          index: j
         });
-        typeof v?.scrollTo == "function" && v.scrollTo({
-          behavior: y,
-          top: W
+        typeof b?.scrollTo == "function" && b.scrollTo({
+          behavior: O,
+          top: D
         });
       }
     }),
-    [v, S, K]
-  ), Z(() => {
-    O >= 0 && b >= 0 && N >= 0 && Y >= 0 && c && c(
+    [b, z, se]
+  ), te(() => {
+    I >= 0 && y >= 0 && A >= 0 && J >= 0 && d && d(
       {
-        columnStartIndex: M,
-        columnStopIndex: w,
-        rowStartIndex: oe,
+        columnStartIndex: R,
+        columnStopIndex: G,
+        rowStartIndex: P,
         rowStopIndex: le
       },
       {
-        columnStartIndex: O,
-        columnStopIndex: b,
-        rowStartIndex: N,
-        rowStopIndex: Y
+        columnStartIndex: I,
+        columnStopIndex: y,
+        rowStartIndex: A,
+        rowStopIndex: J
       }
     );
   }, [
-    c,
-    O,
-    M,
-    b,
-    w,
-    N,
-    oe,
-    Y,
+    d,
+    I,
+    R,
+    y,
+    G,
+    A,
+    P,
+    J,
     le
   ]);
-  const ge = R(() => {
-    const $ = [];
-    if (n > 0 && I > 0)
-      for (let y = N; y <= Y; y++) {
-        const H = V(y), W = [];
-        for (let A = O; A <= b; A++) {
-          const q = G(A);
-          W.push(
-            /* @__PURE__ */ Q(
-              D,
+  const ge = H(() => {
+    const W = [];
+    if (o > 0 && x > 0)
+      for (let O = A; O <= J; O++) {
+        const j = E(O), D = [];
+        for (let k = I; k <= y; k++) {
+          const Q = U(k);
+          D.push(
+            /* @__PURE__ */ C(
+              F,
               {
-                ...E,
+                ...M,
                 ariaAttributes: {
-                  "aria-colindex": A + 1,
+                  "aria-colindex": k + 1,
                   role: "gridcell"
                 },
-                columnIndex: A,
-                key: i ? i({
-                  columnIndex: A,
-                  data: E,
-                  rowIndex: y
-                }) : A,
-                rowIndex: y,
+                columnIndex: k,
+                key: n ? n({
+                  columnIndex: k,
+                  data: M,
+                  rowIndex: O
+                }) : k,
+                rowIndex: O,
                 style: {
                   position: "absolute",
                   left: m ? void 0 : 0,
                   right: m ? 0 : void 0,
-                  transform: `translate(${m ? -q.scrollOffset : q.scrollOffset}px, ${H.scrollOffset}px)`,
-                  height: H.size,
-                  width: q.size
+                  transform: `translate(${m ? -Q.scrollOffset : Q.scrollOffset}px, ${j.scrollOffset}px)`,
+                  height: j.size,
+                  width: Q.size
                 }
               }
             )
           );
         }
-        $.push(
-          /* @__PURE__ */ se(
+        W.push(
+          /* @__PURE__ */ oe(
             "div",
             {
               role: "row",
-              "aria-rowindex": y + 1,
-              children: W
+              "aria-rowindex": O + 1,
+              children: D
             },
-            z ? z({
-              data: E,
-              rowIndex: y
-            }) : y
+            w ? w({
+              data: M,
+              rowIndex: O
+            }) : O
           )
         );
       }
-    return $;
+    return W;
   }, [
-    D,
-    E,
+    F,
+    M,
+    o,
     n,
-    i,
-    O,
-    b,
-    G,
-    V,
-    m,
     I,
-    z,
-    N,
-    Y
-  ]), xe = /* @__PURE__ */ se(
+    y,
+    U,
+    E,
+    m,
+    x,
+    w,
+    A,
+    J
+  ]), ve = /* @__PURE__ */ oe(
     "div",
     {
       "aria-hidden": !0,
       style: {
-        height: _(),
-        width: p(),
+        height: S(),
+        width: v(),
         zIndex: -1
       }
     }
   );
-  return Q(
-    j,
+  return C(
+    B,
     {
-      "aria-colcount": n,
-      "aria-rowcount": I,
+      "aria-colcount": o,
+      "aria-rowcount": x,
       role: "grid",
       ...T,
       className: r,
-      dir: o,
-      ref: U,
+      dir: f,
+      ref: X,
       style: {
         position: "relative",
         maxHeight: "100%",
         maxWidth: "100%",
         flexGrow: 1,
         overflow: "auto",
-        ...u
+        ...g
       }
     },
     ge,
     s,
-    xe
+    ve
   );
 }
-const Ae = L, ke = P;
+const Ve = V, Re = q;
 function Te(e) {
   return e != null && typeof e == "object" && "getAverageRowHeight" in e && typeof e.getAverageRowHeight == "function";
 }
-const ne = "data-react-window-index";
-function Le({
+function Me({
+  element: e,
+  getCellBounds: t,
+  isDynamicRowHeight: s,
+  rowCount: r,
+  rowElements: o,
+  scrollToIndex: n
+}) {
+  const a = q(null), l = q(void 0), c = ee(() => {
+    a.current = null, l.current !== void 0 && (cancelAnimationFrame(l.current), l.current = void 0);
+  }), f = ee(() => {
+    l.current = void 0;
+    const i = a.current;
+    if (!i) return;
+    if (!e || !s || i.index >= r || performance.now() >= i.deadline) {
+      c();
+      return;
+    }
+    const d = n({
+      align: i.align,
+      containerScrollOffset: e.scrollTop,
+      index: i.index
+    });
+    if (d !== void 0) {
+      const u = Math.max(
+        0,
+        Math.min(d, e.scrollHeight - e.clientHeight)
+      );
+      if (Math.abs(u - e.scrollTop) > 1)
+        i.stableFrames = 0, e.scrollTo({ behavior: "instant", top: u });
+      else {
+        const h = o.current;
+        if (!(h.some(
+          (w) => w.getAttribute(Z) === `${i.index}`
+        ) && h.every((w) => {
+          const g = Number(w.getAttribute(Z));
+          return Math.abs(
+            t(g).size - w.offsetHeight
+          ) <= 1;
+        })))
+          i.stableFrames = 0;
+        else if (++i.stableFrames >= 2) {
+          c();
+          return;
+        }
+      }
+    }
+    l.current = requestAnimationFrame(f);
+  });
+  return Y(() => {
+    if (!e) return;
+    const i = (d) => {
+      switch (d.key) {
+        case "ArrowUp":
+        case "ArrowDown":
+        case "PageUp":
+        case "PageDown":
+        case "Home":
+        case "End":
+        case " ":
+          c();
+      }
+    };
+    return e.addEventListener("wheel", c, { passive: !0 }), e.addEventListener("touchstart", c, { passive: !0 }), e.addEventListener("pointerdown", c), e.addEventListener("keydown", i), () => {
+      c(), e.removeEventListener("wheel", c), e.removeEventListener("touchstart", c), e.removeEventListener("pointerdown", c), e.removeEventListener("keydown", i);
+    };
+  }, [c, e]), $(
+    ({
+      align: i = "auto",
+      behavior: d = "auto",
+      index: u
+    }) => {
+      s && i === "smart" && (i = n({
+        align: "auto",
+        containerScrollOffset: e?.scrollTop ?? 0,
+        index: u
+      }) === (e?.scrollTop ?? 0) ? "auto" : "center");
+      const h = n({
+        align: i,
+        containerScrollOffset: e?.scrollTop ?? 0,
+        index: u
+      });
+      c(), typeof e?.scrollTo == "function" && (s && (a.current = {
+        align: i,
+        index: u,
+        deadline: performance.now() + 1e3,
+        stableFrames: 0
+      }, l.current = requestAnimationFrame(f)), e.scrollTo({
+        behavior: s ? "instant" : d,
+        top: h
+      }));
+    },
+    [c, f, e, s, n]
+  );
+}
+const Z = "data-react-window-index";
+function ke({
   children: e,
   className: t,
   defaultHeight: s = 0,
   listRef: r,
-  onResize: n,
-  onRowsRendered: i,
-  overscanCount: l = 3,
-  rowComponent: f,
-  rowCount: a,
-  rowHeight: o,
-  rowKey: d,
-  rowProps: c,
-  tagName: g = "div",
-  style: x,
-  ...I
+  onResize: o,
+  onRowsRendered: n,
+  overscanCount: a = 3,
+  rowComponent: l,
+  rowCount: c,
+  rowHeight: f,
+  rowKey: i,
+  rowProps: d,
+  tagName: u = "div",
+  style: h,
+  ...x
 }) {
-  const h = he(c), z = R(
-    () => ae(f, pe),
-    [f]
-  ), [u, j] = L(null), T = Te(o), E = R(() => T ? (b) => o.getRowHeight(b) ?? o.getAverageRowHeight() : o, [T, o]), {
-    getCellBounds: D,
-    getEstimatedSize: v,
-    scrollToIndex: U,
+  const p = he(d), w = H(
+    () => fe(l, pe),
+    [l]
+  ), [g, B] = V(null), T = Te(f), M = H(() => T ? (E) => f.getRowHeight(E) ?? f.getAverageRowHeight() : f, [T, f]), {
+    getCellBounds: F,
+    getEstimatedSize: b,
+    scrollToIndex: X,
     startIndexOverscan: m,
-    startIndexVisible: G,
-    stopIndexOverscan: p,
-    stopIndexVisible: O
-  } = re({
-    containerElement: u,
-    containerStyle: x,
+    startIndexVisible: U,
+    stopIndexOverscan: v,
+    stopIndexVisible: I
+  } = ie({
+    containerElement: g,
+    containerStyle: h,
     defaultContainerSize: s,
     direction: "vertical",
-    itemCount: a,
-    itemProps: h,
-    itemSize: E,
-    onResize: n,
-    overscanCount: l
+    itemCount: c,
+    itemProps: p,
+    itemSize: M,
+    onResize: o,
+    overscanCount: a
+  }), R = q([]), z = Me({
+    element: g,
+    getCellBounds: F,
+    isDynamicRowHeight: T,
+    rowCount: c,
+    rowElements: R,
+    scrollToIndex: X
   });
-  fe(
+  de(
     r,
     () => ({
       get element() {
-        return u;
+        return g;
       },
-      scrollToRow({
-        align: b = "auto",
-        behavior: w = "auto",
-        index: V
-      }) {
-        const _ = U({
-          align: b,
-          containerScrollOffset: u?.scrollTop ?? 0,
-          index: V
-        });
-        typeof u?.scrollTo == "function" && u.scrollTo({
-          behavior: w,
-          top: _
-        });
-      }
+      scrollToRow: z
     }),
-    [u, U]
-  ), J(() => {
-    if (!u)
+    [g, z]
+  ), Y(() => {
+    if (!g)
       return;
-    const b = Array.from(u.children).filter((w, V) => {
-      if (w.hasAttribute("aria-hidden"))
+    const E = Array.from(g.children).slice(
+      0,
+      m < 0 ? 0 : v - m + 1
+    ).filter((S, A) => {
+      if (S.hasAttribute("aria-hidden"))
         return !1;
-      const _ = `${m + V}`;
-      return w.setAttribute(ne, _), !0;
+      const P = `${m + A}`;
+      return S.setAttribute(Z, P), !0;
     });
-    if (T)
-      return o.observeRowElements(b);
+    if (R.current = E, T)
+      return f.observeRowElements(E);
   }, [
-    u,
+    w,
+    g,
     T,
-    o,
+    c,
+    f,
+    i,
+    p,
     m,
-    p
-  ]), Z(() => {
-    m >= 0 && p >= 0 && i && i(
+    v
+  ]), te(() => {
+    m >= 0 && v >= 0 && n && n(
       {
-        startIndex: G,
-        stopIndex: O
+        startIndex: U,
+        stopIndex: I
       },
       {
         startIndex: m,
-        stopIndex: p
+        stopIndex: v
       }
     );
   }, [
-    i,
+    n,
     m,
-    G,
-    p,
-    O
+    U,
+    v,
+    I
   ]);
-  const M = R(() => {
-    const b = [];
-    if (a > 0)
-      for (let w = m; w <= p; w++) {
-        const V = D(w);
-        b.push(
-          /* @__PURE__ */ Q(
-            z,
+  const y = H(() => {
+    const E = [];
+    if (c > 0)
+      for (let S = m; S <= v; S++) {
+        const A = F(S);
+        E.push(
+          /* @__PURE__ */ C(
+            w,
             {
-              ...h,
+              ...p,
               ariaAttributes: {
-                "aria-posinset": w + 1,
-                "aria-setsize": a,
+                "aria-posinset": S + 1,
+                "aria-setsize": c,
                 role: "listitem"
               },
-              key: d ? d(w, h) : w,
-              index: w,
+              key: i ? i(S, p) : S,
+              index: S,
               style: {
                 position: "absolute",
                 left: 0,
-                transform: `translateY(${V.scrollOffset}px)`,
+                transform: `translateY(${A.scrollOffset}px)`,
                 // In case of dynamic row heights, don't specify a height style
                 // otherwise a default/estimated height would mask the actual height
-                height: T ? void 0 : V.size,
+                height: T ? void 0 : A.size,
                 width: "100%"
               }
             }
           )
         );
       }
-    return b;
+    return E;
   }, [
-    z,
-    D,
+    w,
+    F,
     T,
-    a,
-    d,
-    h,
+    c,
+    i,
+    p,
     m,
-    p
-  ]), S = /* @__PURE__ */ se(
+    v
+  ]), G = /* @__PURE__ */ oe(
     "div",
     {
       "aria-hidden": !0,
       style: {
-        height: v(),
+        height: b(),
         width: "100%",
         zIndex: -1
       }
     }
   );
-  return Q(
-    g,
+  return C(
+    u,
     {
       role: "list",
-      ...I,
+      ...x,
       className: t,
-      ref: j,
+      ref: B,
       style: {
         position: "relative",
         maxHeight: "100%",
         flexGrow: 1,
         overflowY: "auto",
-        ...x
+        ...h
       }
     },
-    M,
+    y,
     e,
-    S
+    G
   );
 }
-function Me({
+function $e({
   defaultRowHeight: e,
   key: t
 }) {
-  const [s, r] = L({
+  const [s, r] = V({
     key: t,
     map: /* @__PURE__ */ new Map()
   });
@@ -902,83 +1030,83 @@ function Me({
     key: t,
     map: /* @__PURE__ */ new Map()
   });
-  const { map: n } = s, i = B(() => {
-    let c = 0;
-    return n.forEach((g) => {
-      c += g;
-    }), c === 0 ? e : c / n.size;
-  }, [e, n]), l = B(
-    (c) => {
-      const g = n.get(c);
-      return g !== void 0 ? g : (n.set(c, e), e);
+  const { map: o } = s, n = $(() => {
+    let d = 0;
+    return o.forEach((u) => {
+      d += u;
+    }), d === 0 ? e : d / o.size;
+  }, [e, o]), a = $(
+    (d) => {
+      const u = o.get(d);
+      return u !== void 0 ? u : e;
     },
-    [e, n]
-  ), f = B((c, g) => {
-    r((x) => {
-      if (x.map.get(c) === g)
-        return x;
-      const I = new Map(x.map);
-      return I.set(c, g), {
-        ...x,
-        map: I
+    [e, o]
+  ), l = $((d, u) => {
+    r((h) => {
+      if (h.map.get(d) === u)
+        return h;
+      const x = new Map(h.map);
+      return x.set(d, u), {
+        ...h,
+        map: x
       };
     });
-  }, []), a = de(
-    (c) => {
-      c.length !== 0 && c.forEach((g) => {
-        const { borderBoxSize: x, target: I } = g, h = I.getAttribute(ne);
-        k(
-          h !== null,
-          `Invalid ${ne} attribute value`
+  }, []), c = ee(
+    (d) => {
+      d.length !== 0 && d.forEach((u) => {
+        const { borderBoxSize: h, target: x } = u, p = x.getAttribute(Z);
+        L(
+          p !== null,
+          `Invalid ${Z} attribute value`
         );
-        const z = parseInt(h), { blockSize: u } = x[0];
-        u && f(z, u);
+        const w = parseInt(p), { blockSize: g } = h[0];
+        g && l(w, g);
       });
     }
-  ), [o] = L(() => {
+  ), [f] = V(() => {
     if (typeof ResizeObserver < "u")
-      return new ResizeObserver(a);
+      return new ResizeObserver(c);
   });
-  Z(() => {
-    if (o)
+  te(() => {
+    if (f)
       return () => {
-        o.disconnect();
+        f.disconnect();
       };
-  }, [o]);
-  const d = B(
-    (c) => o ? (c.forEach((g) => o.observe(g)), () => {
-      c.forEach((g) => o.unobserve(g));
+  }, [f]);
+  const i = $(
+    (d) => f ? (d.forEach((u) => f.observe(u)), () => {
+      d.forEach((u) => f.unobserve(u));
     }) : () => {
     },
-    [o]
+    [f]
   );
-  return R(
+  return H(
     () => ({
-      getAverageRowHeight: i,
-      getRowHeight: l,
-      setRowHeight: f,
-      observeRowElements: d
+      getAverageRowHeight: n,
+      getRowHeight: a,
+      setRowHeight: l,
+      observeRowElements: i
     }),
-    [i, l, f, d]
+    [n, a, l, i]
   );
 }
-const $e = L, He = P;
-let te = -1;
+const He = V, Fe = q;
+let ne = -1;
 function We(e = !1) {
-  if (te === -1 || e) {
+  if (ne === -1 || e) {
     const t = document.createElement("div"), s = t.style;
-    s.width = "50px", s.height = "50px", s.overflow = "scroll", document.body.appendChild(t), te = t.offsetWidth - t.clientWidth, document.body.removeChild(t);
+    s.width = "50px", s.height = "50px", s.overflow = "scroll", document.body.appendChild(t), ne = t.offsetWidth - t.clientWidth, document.body.removeChild(t);
   }
-  return te;
+  return ne;
 }
 export {
-  Ve as Grid,
-  Le as List,
+  Le as Grid,
+  ke as List,
   We as getScrollbarSize,
-  Me as useDynamicRowHeight,
-  Ae as useGridCallbackRef,
-  ke as useGridRef,
-  $e as useListCallbackRef,
-  He as useListRef
+  $e as useDynamicRowHeight,
+  Ve as useGridCallbackRef,
+  Re as useGridRef,
+  He as useListCallbackRef,
+  Fe as useListRef
 };
 //# sourceMappingURL=react-window.js.map