react-window 2.0.0-alpha.5 → 2.0.0-alpha.6

package/dist/react-window.js

@@ -1,435 +1,508 @@
-import { jsx as R } from "react/jsx-runtime";
-import { useLayoutEffect as Y, useEffect as U, useMemo as H, useState as L, useRef as W, useCallback as G, memo as q, useImperativeHandle as A, createElement as _ } from "react";
-const V = typeof window < "u" ? Y : U;
-function F(t) {
-  if (t !== void 0)
-    switch (typeof t) {
+import { jsx as U } from "react/jsx-runtime";
+import { useLayoutEffect as K, useEffect as A, useMemo as E, useState as H, useRef as V, useCallback as G, memo as Q, useImperativeHandle as X, createElement as Z } from "react";
+const F = typeof window < "u" ? K : A;
+function P(e) {
+  if (e !== void 0)
+    switch (typeof e) {
       case "number":
-        return t;
+        return e;
       case "string": {
-        if (t.endsWith("px"))
-          return parseFloat(t);
+        if (e.endsWith("px"))
+          return parseFloat(e);
         break;
       }
     }
 }
-function K({
-  box: t,
-  defaultHeight: s,
-  defaultWidth: n,
-  disabled: r,
-  element: e,
+function te({
+  box: e,
+  defaultHeight: t,
+  defaultWidth: s,
+  disabled: i,
+  element: o,
   mode: f,
-  style: i
+  style: n
 }) {
-  const { styleHeight: c, styleWidth: o } = H(
+  const { styleHeight: c, styleWidth: r } = E(
     () => ({
-      styleHeight: F(i?.height),
-      styleWidth: F(i?.width)
+      styleHeight: P(n?.height),
+      styleWidth: P(n?.width)
     }),
-    [i?.height, i?.width]
-  ), [u, m] = L({
-    height: s,
-    width: n
-  }), z = r || f === "only-height" && c !== void 0 || f === "only-width" && o !== void 0 || c !== void 0 && o !== void 0;
-  return V(() => {
-    if (e === null || z)
+    [n?.height, n?.width]
+  ), [d, h] = H({
+    height: t,
+    width: s
+  }), m = i || f === "only-height" && c !== void 0 || f === "only-width" && r !== void 0 || c !== void 0 && r !== void 0;
+  return F(() => {
+    if (o === null || m)
       return;
-    const O = new ResizeObserver((x) => {
-      for (const v of x) {
-        const { contentRect: w, target: I } = v;
-        e === I && m((h) => h.height === w.height && h.width === w.width ? h : {
+    const b = new ResizeObserver((v) => {
+      for (const a of v) {
+        const { contentRect: w, target: g } = a;
+        o === g && h((u) => u.height === w.height && u.width === w.width ? u : {
           height: w.height,
           width: w.width
         });
       }
     });
-    return O.observe(e, { box: t }), () => {
-      O?.unobserve(e);
+    return b.observe(o, { box: e }), () => {
+      b?.unobserve(o);
     };
-  }, [t, z, e, c, o]), H(
+  }, [e, m, o, c, r]), E(
     () => ({
-      height: c ?? u.height,
-      width: o ?? u.width
+      height: c ?? d.height,
+      width: r ?? d.width
     }),
-    [u, c, o]
+    [d, c, r]
   );
 }
-function Q(t) {
-  const s = W(() => {
+function se(e) {
+  const t = V(() => {
     throw new Error("Cannot call an event handler while rendering.");
   });
-  return V(() => {
-    s.current = t;
-  }, [t]), G((n) => s.current?.(n), [s]);
+  return F(() => {
+    t.current = e;
+  }, [e]), G((s) => t.current?.(s), [t]);
 }
-function $(t, s = "Assertion error") {
-  if (!t)
-    throw console.error(s), Error(s);
+function $(e, t = "Assertion error") {
+  if (!e)
+    throw console.error(t), Error(t);
 }
-function X({
-  cachedBounds: t,
-  itemCount: s,
-  itemSize: n
+function _({
+  cachedBounds: e,
+  itemCount: t,
+  itemSize: s
 }) {
-  if (typeof n == "number")
-    return s * n;
-  if (t.size > 0) {
-    const r = t.get(t.size - 1);
-    $(r !== void 0, "Unexpected bounds cache miss");
-    const e = (r.scrollOffset + r.size) / t.size;
-    return s * e;
-  } else
+  if (t === 0)
     return 0;
+  if (typeof s == "number")
+    return t * s;
+  {
+    const i = e.get(
+      e.size === 0 ? 0 : e.size - 1
+    );
+    $(i !== void 0, "Unexpected bounds cache miss");
+    const o = (i.scrollOffset + i.size) / e.size;
+    return t * o;
+  }
 }
-function Z({
-  align: t,
-  cachedBounds: s,
-  index: n,
-  itemCount: r,
-  containerScrollOffset: e,
-  containerSize: f
+function oe({
+  align: e,
+  cachedBounds: t,
+  index: s,
+  itemCount: i,
+  itemSize: o,
+  containerScrollOffset: f,
+  containerSize: n
 }) {
-  const i = s.get(r - 1).scrollOffset, c = i + i - f, o = Math.max(
+  const c = _({
+    cachedBounds: t,
+    itemCount: i,
+    itemSize: o
+  }), r = t.get(s), d = Math.max(
     0,
-    s.get(n + 1).scrollOffset - f
-  ), u = Math.min(
-    i,
-    s.get(n).scrollOffset
+    Math.min(c - n, r.scrollOffset)
+  ), h = Math.max(
+    0,
+    r.scrollOffset - n + r.size
   );
-  switch (t === "smart" && (e >= o && e <= u ? t = "auto" : t = "center"), t) {
+  switch (e === "smart" && (f >= h && f <= d ? e = "auto" : e = "center"), e) {
     case "start":
-      return Math.min(c, u);
+      return d;
     case "end":
-      return o;
-    case "center": {
-      const m = Math.round(
-        o + (u - o) / 2
-      );
-      return m < Math.ceil(f / 2) ? 0 : m > c ? c : m;
-    }
+      return h;
+    case "center":
+      return r.scrollOffset <= n / 2 ? 0 : r.scrollOffset + r.size / 2 >= c - n / 2 ? c - n : r.scrollOffset + r.size / 2 - n / 2;
     case "auto":
     default:
-      return e >= o && e <= u ? e : e < o ? o : u;
+      return f >= h && f <= d ? f : f < h ? h : d;
   }
 }
-function tt({
-  cachedBounds: t,
-  containerScrollOffset: s,
-  containerSize: n,
-  itemCount: r,
-  overscanCount: e
+function D({
+  cachedBounds: e,
+  containerScrollOffset: t,
+  containerSize: s,
+  itemCount: i,
+  overscanCount: o
 }) {
-  const f = r - 1;
-  let i = 0, c = -1, o = 0;
-  for (; o < f; ) {
-    const u = t.get(o);
-    if (u.scrollOffset + u.size > s)
+  const f = i - 1;
+  let n = 0, c = -1, r = 0;
+  for (; r < f; ) {
+    const d = e.get(r);
+    if (d.scrollOffset + d.size > t)
       break;
-    o++;
+    r++;
   }
-  for (i = o, i = Math.max(0, i - e); o < f; ) {
-    const u = t.get(o);
-    if (u.scrollOffset + u.size >= s + n)
+  for (n = r, n = Math.max(0, n - o); r < f; ) {
+    const d = e.get(r);
+    if (d.scrollOffset + d.size >= t + s)
       break;
-    o++;
+    r++;
   }
-  return c = Math.min(f, o), c = Math.min(r - 1, c + e), i < 0 ? [0, -1] : [i, c];
+  return c = Math.min(f, r), c = Math.min(i - 1, c + o), n < 0 ? [0, -1] : [n, c];
 }
-function et({
-  itemCount: t,
-  itemProps: s,
-  itemSize: n
+function re({
+  itemCount: e,
+  itemProps: t,
+  itemSize: s
 }) {
-  const r = /* @__PURE__ */ new Map();
+  const i = /* @__PURE__ */ new Map();
   return {
-    get(e) {
-      for ($(e < t, `Invalid index ${e}`); r.size - 1 < e; ) {
-        const i = r.size, c = typeof n == "number" ? n : n(i, s);
-        if (i === 0)
-          r.set(i, {
+    get(o) {
+      for ($(o < e, `Invalid index ${o}`); i.size - 1 < o; ) {
+        const n = i.size;
+        let c;
+        switch (typeof s) {
+          case "function": {
+            c = s(n, t);
+            break;
+          }
+          case "number": {
+            c = s;
+            break;
+          }
+        }
+        if (n === 0)
+          i.set(n, {
             size: c,
             scrollOffset: 0
           });
         else {
-          const o = r.get(i - 1);
+          const r = i.get(n - 1);
           $(
-            o !== void 0,
-            `Unexpected bounds cache miss for index ${e}`
-          ), r.set(i, {
-            scrollOffset: o.scrollOffset + o.size,
+            r !== void 0,
+            `Unexpected bounds cache miss for index ${o}`
+          ), i.set(n, {
+            scrollOffset: r.scrollOffset + r.size,
             size: c
           });
         }
       }
-      const f = r.get(e);
+      const f = i.get(o);
       return $(
         f !== void 0,
-        `Unexpected bounds cache miss for index ${e}`
+        `Unexpected bounds cache miss for index ${o}`
       ), f;
     },
-    set(e, f) {
-      r.set(e, f);
+    set(o, f) {
+      i.set(o, f);
     },
     get size() {
-      return r.size;
+      return i.size;
     }
   };
 }
-function st({
-  itemCount: t,
-  itemProps: s,
-  itemSize: n
+function ie({
+  itemCount: e,
+  itemProps: t,
+  itemSize: s
 }) {
-  return H(
-    () => et({
-      itemCount: t,
-      itemProps: s,
-      itemSize: n
+  return E(
+    () => re({
+      itemCount: e,
+      itemProps: t,
+      itemSize: s
     }),
-    [t, s, n]
+    [e, t, s]
   );
 }
-function B({
-  containerElement: t,
-  containerStyle: s,
-  defaultContainerSize: n = 0,
-  direction: r,
-  itemCount: e,
+function ne({
+  containerSize: e,
+  itemSize: t
+}) {
+  let s;
+  switch (typeof t) {
+    case "string": {
+      $(
+        t.endsWith("%"),
+        `Invalid item size: "${t}"; string values must be percentages (e.g. "100%")`
+      ), $(
+        e !== void 0,
+        "Container size must be defined if a percentage item size is specified"
+      ), s = e * parseInt(t) / 100;
+      break;
+    }
+    default: {
+      s = t;
+      break;
+    }
+  }
+  return s;
+}
+function q({
+  containerElement: e,
+  containerStyle: t,
+  defaultContainerSize: s = 0,
+  direction: i,
+  itemCount: o,
   itemProps: f,
-  itemSize: i,
+  itemSize: n,
   onResize: c,
-  overscanCount: o
+  overscanCount: r
 }) {
-  const [u, m] = L([0, -1]), [z, O] = [
-    Math.min(e - 1, u[0]),
-    Math.min(e - 1, u[1])
-  ], { height: x = n, width: v = n } = K({
-    defaultHeight: r === "vertical" ? n : void 0,
-    defaultWidth: r === "horizontal" ? n : void 0,
-    element: t,
-    mode: r === "vertical" ? "only-height" : "only-width",
-    style: s
-  }), w = W({
+  const [d, h] = H([0, -1]), [m, b] = [
+    Math.min(o - 1, d[0]),
+    Math.min(o - 1, d[1])
+  ], { height: v = s, width: a = s } = te({
+    defaultHeight: i === "vertical" ? s : void 0,
+    defaultWidth: i === "horizontal" ? s : void 0,
+    element: e,
+    mode: i === "vertical" ? "only-height" : "only-width",
+    style: t
+  }), w = V({
     height: 0,
     width: 0
-  });
-  Y(() => {
+  }), g = i === "vertical" ? v : a, u = ne({ containerSize: g, itemSize: n });
+  K(() => {
     if (typeof c == "function") {
       const l = w.current;
-      (l.height !== x || l.width !== v) && (c({ height: x, width: v }, { ...l }), l.height = x, l.width = v);
+      (l.height !== v || l.width !== a) && (c({ height: v, width: a }, { ...l }), l.height = v, l.width = a);
     }
-  }, [x, c, v]);
-  const I = r === "vertical" ? x : v, h = st({
-    itemCount: e,
+  }, [v, c, a]);
+  const p = ie({
+    itemCount: o,
     itemProps: f,
-    itemSize: i
-  }), y = G(
-    (l) => h.get(l),
-    [h]
-  ), P = G(
-    () => X({
-      cachedBounds: h,
-      itemCount: e,
-      itemSize: i
+    itemSize: u
+  }), O = G(
+    (l) => p.get(l),
+    [p]
+  ), T = G(
+    () => _({
+      cachedBounds: p,
+      itemCount: o,
+      itemSize: u
     }),
-    [h, e, i]
-  ), a = G(
-    (l) => tt({
-      cachedBounds: h,
+    [p, o, u]
+  ), y = G(
+    (l) => D({
+      cachedBounds: p,
       containerScrollOffset: l,
-      containerSize: I,
-      itemCount: e,
-      overscanCount: o
+      containerSize: g,
+      itemCount: o,
+      overscanCount: r
     }),
-    [h, I, e, o]
+    [p, g, o, r]
   );
-  V(() => {
-    const l = (r === "vertical" ? t?.scrollTop : t?.scrollLeft) ?? 0;
-    m(a(l));
-  }, [t, r, a]);
-  const d = Q(
+  F(() => {
+    const l = (i === "vertical" ? e?.scrollTop : e?.scrollLeft) ?? 0;
+    h(y(l));
+  }, [e, i, y]), F(() => {
+    if (!e)
+      return;
+    const l = () => {
+      h((x) => {
+        const R = i === "vertical" ? e.scrollTop : e.scrollLeft, I = D({
+          cachedBounds: p,
+          containerScrollOffset: R,
+          containerSize: g,
+          itemCount: o,
+          overscanCount: r
+        });
+        return I[0] === x[0] && I[1] === x[1] ? x : I;
+      });
+    };
+    return e.addEventListener("scroll", l), () => {
+      e.removeEventListener("scroll", l);
+    };
+  }, [
+    p,
+    e,
+    g,
+    i,
+    o,
+    r
+  ]);
+  const S = se(
     ({
       align: l = "auto",
-      behavior: T = "auto",
-      containerScrollOffset: p,
-      index: g
+      behavior: x = "auto",
+      containerScrollOffset: R,
+      index: I
     }) => {
-      const k = Z({
+      const W = oe({
         align: l,
-        cachedBounds: h,
-        containerScrollOffset: p,
-        containerSize: I,
-        index: g,
-        itemCount: e
-      });
-      r === "horizontal" ? t?.scrollTo({
-        left: k,
-        behavior: T || void 0
-      }) : t?.scrollTo({
-        behavior: T || void 0,
-        top: k
+        cachedBounds: p,
+        containerScrollOffset: R,
+        containerSize: g,
+        index: I,
+        itemCount: o,
+        itemSize: u
       });
+      if (e)
+        if (typeof e.scrollTo == "function")
+          i === "horizontal" ? e.scrollTo({
+            left: W,
+            behavior: x || void 0
+          }) : e.scrollTo({
+            behavior: x || void 0,
+            top: W
+          });
+        else {
+          const k = y(W);
+          (k[0] !== m || k[1] !== b) && h(k);
+        }
     }
   );
   return {
-    getCellBounds: y,
-    getEstimatedHeight: P,
-    onScroll: () => {
-      const l = a(
-        (r === "vertical" ? t?.scrollTop : t?.scrollLeft) ?? 0
-      );
-      (l[0] !== z || l[1] !== O) && m(l);
-    },
-    scrollToIndex: d,
-    startIndex: z,
-    stopIndex: O
+    getCellBounds: O,
+    getEstimatedSize: T,
+    scrollToIndex: S,
+    startIndex: m,
+    stopIndex: b
   };
 }
-function C(t) {
-  return H(() => t, Object.values(t));
+function N(e) {
+  return E(() => e, Object.values(e));
 }
-function N(t, s) {
-  if (t === s)
+function J(e, t) {
+  if (e === t)
     return !0;
-  if (!!t != !!s || ($(t !== void 0), $(s !== void 0), Object.keys(t).length !== Object.keys(s).length))
+  if (!!e != !!t || ($(e !== void 0), $(t !== void 0), Object.keys(e).length !== Object.keys(t).length))
     return !1;
-  for (const n in t)
-    if (!Object.is(s[n], t[n]))
+  for (const s in e)
+    if (!Object.is(t[s], e[s]))
       return !1;
   return !0;
 }
-function D(t, s) {
-  const { style: n, ...r } = t, { style: e, ...f } = s;
-  return N(n, e) && N(r, f);
+function C(e, t) {
+  const { style: s, ...i } = e, { style: o, ...f } = t;
+  return J(s, o) && J(i, f);
 }
-const J = () => {
-};
-function nt({
-  cellComponent: t,
-  cellProps: s,
-  className: n,
-  columnCount: r,
-  columnWidth: e,
+function fe({
+  cellComponent: e,
+  cellProps: t,
+  className: s,
+  columnCount: i,
+  columnWidth: o,
   defaultHeight: f = 0,
-  defaultWidth: i = 0,
+  defaultWidth: n = 0,
   gridRef: c,
-  onCellsRendered: o,
-  onResize: u,
-  onScroll: m = J,
-  overscanCount: z = 3,
-  rowCount: O,
-  rowHeight: x,
+  onCellsRendered: r,
+  onResize: d,
+  overscanCount: h = 3,
+  rowCount: m,
+  rowHeight: b,
   style: v,
-  ...w
+  ...a
 }) {
-  const I = C(s), h = H(
-    () => q(t, D),
-    [t]
-  ), [y, P] = L(null), a = B({
-    containerElement: y,
-    defaultContainerSize: i,
+  const w = N(t), g = E(
+    () => Q(e, C),
+    [e]
+  ), [u, p] = H(null), {
+    getCellBounds: O,
+    getEstimatedSize: T,
+    startIndex: y,
+    scrollToIndex: S,
+    stopIndex: l
+  } = q({
+    containerElement: u,
+    defaultContainerSize: n,
     direction: "horizontal",
-    itemCount: r,
-    itemProps: I,
-    itemSize: e,
-    onResize: u,
-    overscanCount: z
-  }), d = B({
-    containerElement: y,
+    itemCount: i,
+    itemProps: w,
+    itemSize: o,
+    onResize: d,
+    overscanCount: h
+  }), {
+    getCellBounds: x,
+    getEstimatedSize: R,
+    startIndex: I,
+    scrollToIndex: W,
+    stopIndex: k
+  } = q({
+    containerElement: u,
     defaultContainerSize: f,
     direction: "vertical",
-    itemCount: O,
-    itemProps: I,
-    itemSize: x,
-    onResize: u,
-    overscanCount: z
-  }), { startIndex: l, stopIndex: T } = a, { startIndex: p, stopIndex: g } = d;
-  A(
+    itemCount: m,
+    itemProps: w,
+    itemSize: b,
+    onResize: d,
+    overscanCount: h
+  });
+  X(
     c,
     () => ({
       get element() {
-        return y;
+        return u;
       },
       scrollToCell({
-        behavior: b = "auto",
-        columnAlign: S = "auto",
-        columnIndex: E,
-        rowAlign: M = "auto",
+        behavior: L = "auto",
+        columnAlign: z = "auto",
+        columnIndex: M,
+        rowAlign: B = "auto",
         rowIndex: j
       }) {
-        d?.scrollToIndex({
-          align: M,
-          behavior: b,
-          containerScrollOffset: y?.scrollTop ?? 0,
+        W({
+          align: B,
+          behavior: L,
+          containerScrollOffset: u?.scrollTop ?? 0,
           index: j
-        }), a?.scrollToIndex({
-          align: S,
-          behavior: b,
-          containerScrollOffset: y?.scrollLeft ?? 0,
-          index: E
+        }), S({
+          align: z,
+          behavior: L,
+          containerScrollOffset: u?.scrollLeft ?? 0,
+          index: M
         });
       },
       scrollToColumn({
-        align: b = "auto",
-        behavior: S = "auto",
-        index: E
+        align: L = "auto",
+        behavior: z = "auto",
+        index: M
       }) {
-        a?.scrollToIndex({
-          align: b,
-          behavior: S,
-          containerScrollOffset: y?.scrollLeft ?? 0,
-          index: E
+        S({
+          align: L,
+          behavior: z,
+          containerScrollOffset: u?.scrollLeft ?? 0,
+          index: M
         });
       },
       scrollToRow({
-        align: b = "auto",
-        behavior: S = "auto",
-        index: E
+        align: L = "auto",
+        behavior: z = "auto",
+        index: M
       }) {
-        d?.scrollToIndex({
-          align: b,
-          behavior: S,
-          containerScrollOffset: y?.scrollTop ?? 0,
-          index: E
+        W({
+          align: L,
+          behavior: z,
+          containerScrollOffset: u?.scrollTop ?? 0,
+          index: M
         });
       }
     }),
-    [a, y, d]
-  ), U(() => {
-    l >= 0 && T >= 0 && p >= 0 && g >= 0 && o && o({
-      columnStartIndex: l,
-      columnStopIndex: T,
-      rowStartIndex: p,
-      rowStopIndex: g
+    [u, S, W]
+  ), A(() => {
+    y >= 0 && l >= 0 && I >= 0 && k >= 0 && r && r({
+      columnStartIndex: y,
+      columnStopIndex: l,
+      rowStartIndex: I,
+      rowStopIndex: k
     });
   }, [
-    o,
+    r,
+    y,
     l,
-    T,
-    p,
-    g
+    I,
+    k
   ]);
-  const k = H(() => {
-    const b = [];
-    if (a && r > 0 && d && O > 0)
-      for (let S = p; S <= g; S++) {
-        const E = d.getCellBounds(S);
-        for (let M = l; M <= T; M++) {
-          const j = a.getCellBounds(M);
-          b.push(
-            /* @__PURE__ */ _(
-              h,
+  const ee = E(() => {
+    const L = [];
+    if (i > 0 && m > 0)
+      for (let z = I; z <= k; z++) {
+        const M = x(z);
+        for (let B = y; B <= l; B++) {
+          const j = O(B);
+          L.push(
+            /* @__PURE__ */ Z(
+              g,
               {
-                ...I,
-                columnIndex: M,
-                key: `${S}-${M}`,
-                rowIndex: S,
+                ...w,
+                columnIndex: B,
+                key: `${z}-${B}`,
+                rowIndex: z,
                 style: {
                   position: "absolute",
                   left: 0,
-                  transform: `translate(${j.scrollOffset}px, ${E.scrollOffset}px)`,
-                  height: E.size,
+                  transform: `translate(${j.scrollOffset}px, ${M.scrollOffset}px)`,
+                  height: m > 1 ? M.size : "100%",
                   width: j.size
                 }
               }
@@ -437,175 +510,179 @@ function nt({
           );
         }
       }
-    return b;
+    return L;
   }, [
-    h,
-    I,
-    r,
+    g,
+    w,
+    i,
+    y,
     l,
-    T,
-    a,
     O,
-    p,
-    g,
-    d
+    x,
+    m,
+    I,
+    k
   ]);
-  return /* @__PURE__ */ R(
+  return /* @__PURE__ */ U(
     "div",
     {
       role: "grid",
-      ...w,
-      className: n,
-      onScroll: (b) => {
-        a.onScroll(), d.onScroll(), m(b);
-      },
-      ref: P,
+      ...a,
+      className: s,
+      ref: p,
       style: {
+        width: "100%",
+        height: "100%",
         ...v,
         maxHeight: "100%",
         maxWidth: "100%",
         flexGrow: 1,
         overflow: "auto"
       },
-      children: /* @__PURE__ */ R(
+      children: /* @__PURE__ */ U(
         "div",
         {
-          className: n,
+          className: s,
           style: {
             position: "relative",
-            height: d?.getEstimatedHeight(),
-            width: a?.getEstimatedHeight()
+            height: R(),
+            width: T()
           },
-          children: k
+          children: ee
         }
       )
     }
   );
 }
-const lt = L, it = W;
-function ct({
-  className: t,
-  defaultHeight: s = 0,
-  listRef: n,
-  onResize: r,
-  onRowsRendered: e,
-  onScroll: f = J,
-  overscanCount: i = 3,
-  rowComponent: c,
-  rowCount: o,
-  rowHeight: u,
-  rowProps: m,
-  style: z,
-  ...O
+const de = H, ue = V;
+function he({
+  className: e,
+  defaultHeight: t = 0,
+  listRef: s,
+  onResize: i,
+  onRowsRendered: o,
+  overscanCount: f = 3,
+  rowComponent: n,
+  rowCount: c,
+  rowHeight: r,
+  rowProps: d,
+  style: h,
+  ...m
 }) {
-  const x = C(m), v = H(
-    () => q(c, D),
-    [c]
-  ), [w, I] = L(null), {
-    getCellBounds: h,
-    getEstimatedHeight: y,
-    onScroll: P,
-    scrollToIndex: a,
-    startIndex: d,
-    stopIndex: l
-  } = B({
-    containerElement: w,
-    defaultContainerSize: s,
+  const b = N(d), v = E(
+    () => Q(n, C),
+    [n]
+  ), [a, w] = H(null), {
+    getCellBounds: g,
+    getEstimatedSize: u,
+    scrollToIndex: p,
+    startIndex: O,
+    stopIndex: T
+  } = q({
+    containerElement: a,
+    defaultContainerSize: t,
     direction: "vertical",
-    itemCount: o,
-    itemProps: x,
-    itemSize: u,
-    onResize: r,
-    overscanCount: i
+    itemCount: c,
+    itemProps: b,
+    itemSize: r,
+    onResize: i,
+    overscanCount: f
   });
-  A(
-    n,
+  X(
+    s,
     () => ({
       get element() {
-        return w;
+        return a;
       },
       scrollToRow({
-        align: p = "auto",
-        behavior: g = "auto",
-        index: k
+        align: S = "auto",
+        behavior: l = "auto",
+        index: x
       }) {
-        a({
-          align: p,
-          behavior: g,
-          containerScrollOffset: w?.scrollTop ?? 0,
-          index: k
+        p({
+          align: S,
+          behavior: l,
+          containerScrollOffset: a?.scrollTop ?? 0,
+          index: x
         });
       }
     }),
-    [w, a]
-  ), U(() => {
-    d >= 0 && l >= 0 && e && e({
-      startIndex: d,
-      stopIndex: l
+    [a, p]
+  ), A(() => {
+    O >= 0 && T >= 0 && o && o({
+      startIndex: O,
+      stopIndex: T
     });
-  }, [e, d, l]);
-  const T = H(() => {
-    const p = [];
-    if (o > 0)
-      for (let g = d; g <= l; g++) {
-        const k = h(g);
-        p.push(
-          /* @__PURE__ */ _(
+  }, [o, O, T]);
+  const y = E(() => {
+    const S = [];
+    if (c > 0)
+      for (let l = O; l <= T; l++) {
+        const x = g(l);
+        S.push(
+          /* @__PURE__ */ Z(
             v,
             {
-              ...x,
-              key: g,
-              index: g,
+              ...b,
+              key: l,
+              index: l,
               style: {
                 position: "absolute",
                 left: 0,
-                transform: `translateY(${k.scrollOffset}px)`,
-                height: k.size,
+                transform: `translateY(${x.scrollOffset}px)`,
+                height: x.size,
                 width: "100%"
               }
             }
           )
         );
       }
-    return p;
-  }, [v, h, o, x, d, l]);
-  return /* @__PURE__ */ R(
+    return S;
+  }, [v, g, c, b, O, T]);
+  return /* @__PURE__ */ U(
     "div",
     {
       role: "list",
-      ...O,
-      className: t,
-      onScroll: (p) => {
-        P(), f(p);
-      },
-      ref: I,
+      ...m,
+      className: e,
+      ref: w,
       style: {
-        ...z,
+        ...h,
         maxHeight: "100%",
         flexGrow: 1,
         overflowY: "auto"
       },
-      children: /* @__PURE__ */ R(
+      children: /* @__PURE__ */ U(
         "div",
         {
-          className: t,
+          className: e,
           style: {
-            height: y(),
+            height: u(),
             position: "relative",
             width: "100%"
           },
-          children: T
+          children: y
         }
       )
     }
   );
 }
-const ft = L, ut = W;
+const ae = H, ge = V;
+let Y = -1;
+function pe(e = !1) {
+  if (Y === -1 || e) {
+    const t = document.createElement("div"), s = t.style;
+    s.width = "50px", s.height = "50px", s.overflow = "scroll", document.body.appendChild(t), Y = t.offsetWidth - t.clientWidth, document.body.removeChild(t);
+  }
+  return Y;
+}
 export {
-  nt as Grid,
-  ct as List,
-  lt as useGridCallbackRef,
-  it as useGridRef,
-  ft as useListCallbackRef,
-  ut as useListRef
+  fe as Grid,
+  he as List,
+  pe as getScrollbarSize,
+  de as useGridCallbackRef,
+  ue as useGridRef,
+  ae as useListCallbackRef,
+  ge as useListRef
 };
+//# sourceMappingURL=react-window.js.map