react-window 2.4.1 → 2.5.1

package/dist/react-window.js

@@ -1,8 +1,8 @@
 "use client";
-import { jsx as re } from "react/jsx-runtime";
-import { useLayoutEffect as Te, useEffect as ie, useState as M, useSyncExternalStore as Re, useMemo as N, useRef as H, useCallback as U, memo as ge, useImperativeHandle as xe, createElement as le, Fragment as ue } from "react";
-const W = typeof window < "u" ? Te : ie;
-function we(e) {
+import { jsx as ue } from "react/jsx-runtime";
+import { useLayoutEffect as _e, useEffect as le, useState as C, useSyncExternalStore as Be, useMemo as q, useRef as P, useCallback as X, memo as Le, useImperativeHandle as Me, createElement as he, Fragment as be } from "react";
+const B = typeof window < "u" ? _e : le;
+function Ae(e) {
   let t = e;
   for (; t; ) {
     if (t.dir)
@@ -11,30 +11,30 @@ function we(e) {
   }
   return !1;
 }
-function Ae(e, t) {
-  const [s, o] = M(t === "rtl");
-  return W(() => {
-    t ? o(t === "rtl") : e && o(we(e));
-  }, [t, e]), s;
+function Ee(e, t) {
+  const [r, o] = C(t === "rtl");
+  return B(() => {
+    t ? o(t === "rtl") : e && o(Ae(e));
+  }, [t, e]), r;
 }
-function Me() {
+function Pe() {
   return () => {
   };
 }
-function Ie() {
-  return Re(
-    Me,
+function We() {
+  return Be(
+    Pe,
     () => !1,
     () => !0
   );
 }
-function ae(e) {
+function Z(e) {
   return e?.ownerDocument.defaultView ?? window;
 }
-function Oe(e) {
-  return ae(e).ResizeObserver ?? (typeof ResizeObserver < "u" ? ResizeObserver : void 0);
+function we(e) {
+  return Z(e).ResizeObserver ?? (typeof ResizeObserver < "u" ? ResizeObserver : void 0);
 }
-function de(e) {
+function me(e) {
   if (e !== void 0)
     switch (typeof e) {
       case "number":
@@ -46,172 +46,258 @@ function de(e) {
       }
     }
 }
-function Le({
+function De({
   box: e,
   defaultHeight: t,
-  defaultWidth: s,
+  defaultWidth: r,
   disabled: o,
-  element: r,
-  mode: n,
-  style: i
+  element: s,
+  mode: i,
+  style: n
 }) {
-  const { styleHeight: l, styleWidth: a } = N(
+  const { styleHeight: d, styleWidth: v } = q(
     () => ({
-      styleHeight: de(i?.height),
-      styleWidth: de(i?.width)
+      styleHeight: me(n?.height),
+      styleWidth: me(n?.width)
     }),
-    [i?.height, i?.width]
-  ), [v, f] = M({
+    [n?.height, n?.width]
+  ), [h, f] = C({
     height: t,
-    width: s
-  }), c = o || n === "only-height" && l !== void 0 || n === "only-width" && a !== void 0 || l !== void 0 && a !== void 0;
-  return W(() => {
-    if (r === null || c)
+    width: r
+  }), u = o || i === "only-height" && d !== void 0 || i === "only-width" && v !== void 0 || d !== void 0 && v !== void 0;
+  return B(() => {
+    if (s === null || u)
       return;
-    const u = Oe(r);
-    if (!u)
+    const a = we(s);
+    if (!a)
       return;
-    const p = new u((d) => {
-      for (const x of d) {
-        const { contentRect: h, target: O } = x;
-        r === O && f((g) => g.height === h.height && g.width === h.width ? g : {
-          height: h.height,
-          width: h.width
+    const c = new a((l) => {
+      for (const p of l) {
+        const { contentRect: b, target: S } = p;
+        s === S && f((w) => w.height === b.height && w.width === b.width ? w : {
+          height: b.height,
+          width: b.width
         });
       }
     });
-    return p.observe(r, { box: e }), () => {
-      p?.unobserve(r);
+    return c.observe(s, { box: e }), () => {
+      c?.unobserve(s);
     };
-  }, [e, c, r, l, a]), N(
+  }, [e, u, s, d, v]), q(
     () => ({
-      height: l ?? v.height,
-      width: a ?? v.width
+      height: d ?? h.height,
+      width: v ?? h.width
     }),
-    [v, l, a]
+    [h, d, v]
   );
 }
-function ee(e) {
-  const t = H(() => {
+function ie(e) {
+  const t = P(() => {
     throw new Error("Cannot call an event handler while rendering.");
   });
-  return W(() => {
+  return B(() => {
     t.current = e;
-  }, [e]), U((...s) => t.current?.(...s), [t]);
+  }, [e]), X((...r) => t.current?.(...r), [t]);
 }
-const he = /* @__PURE__ */ new WeakMap();
-function Ee(e = !1, t = document) {
-  let s = he.get(t);
-  if (s === void 0 || e) {
-    const o = t.createElement("div"), r = o.style;
-    r.width = "50px", r.height = "50px", r.overflow = "scroll", r.direction = "rtl";
-    const n = t.createElement("div"), i = n.style;
-    i.width = "100px", i.height = "100px", o.appendChild(n), t.body.appendChild(o), o.scrollLeft > 0 ? s = "positive-descending" : (o.scrollLeft = 1, o.scrollLeft === 0 ? s = "negative" : s = "positive-ascending"), t.body.removeChild(o), he.set(t, s);
+const xe = /* @__PURE__ */ new WeakMap();
+function Ue(e = !1, t = document) {
+  let r = xe.get(t);
+  if (r === void 0 || e) {
+    const o = t.createElement("div"), s = o.style;
+    s.width = "50px", s.height = "50px", s.overflow = "scroll", s.direction = "rtl";
+    const i = t.createElement("div"), n = i.style;
+    n.width = "100px", n.height = "100px", o.appendChild(i), t.body.appendChild(o), o.scrollLeft > 0 ? r = "positive-descending" : (o.scrollLeft = 1, o.scrollLeft === 0 ? r = "negative" : r = "positive-ascending"), t.body.removeChild(o), xe.set(t, r);
   }
-  return s;
+  return r;
 }
-function C({
+function ne({
   containerElement: e,
   direction: t,
-  isRtl: s,
+  isRtl: r,
   scrollOffset: o
 }) {
-  if (t === "horizontal" && s)
-    switch (Ee(!1, e?.ownerDocument ?? document)) {
+  if (t === "horizontal" && r)
+    switch (Ue(!1, e?.ownerDocument ?? document)) {
       case "negative":
         return -o;
       case "positive-descending": {
         if (e) {
-          const { clientWidth: r, scrollWidth: n } = e;
-          return n - r - o;
+          const { clientWidth: s, scrollWidth: i } = e;
+          return i - s - o;
         }
         break;
       }
     }
   return o;
 }
-function $(e, t = "Assertion error") {
+function Ce({
+  container: e,
+  element: t,
+  onChange: r
+}) {
+  const o = Z(t), s = we(t), i = o.MutationObserver ?? (typeof MutationObserver < "u" ? MutationObserver : void 0), n = s ? new s(r) : void 0, d = (u) => !u.isConnected || (u.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0, v = i ? new i((u) => {
+    u.some(
+      (c) => Array.from(c.addedNodes).some(d) || // Removed nodes preceded the element if the node after them still does (or contains the element)
+      c.removedNodes.length > 0 && c.nextSibling !== null && d(c.nextSibling)
+    ) && (f(), r());
+  }) : void 0, h = /* @__PURE__ */ new Set(), f = () => {
+    for (const a of h)
+      n?.unobserve(a);
+    h.clear(), v?.disconnect();
+    let u = t;
+    for (; u !== e; ) {
+      const a = u.parentElement;
+      if (a === null)
+        break;
+      if (n)
+        for (let c = u.previousElementSibling; c !== null; c = c.previousElementSibling)
+          h.add(c), n.observe(c);
+      v?.observe(a, { childList: !0 }), u = a;
+    }
+  };
+  return f(), () => {
+    n?.disconnect(), v?.disconnect();
+  };
+}
+function ce(e) {
+  return e.window === e;
+}
+function $e(e, t) {
+  return t === "window" ? e ? Z(e) : null : t ?? null;
+}
+function de(e, t) {
+  return ce(e) ? t === "vertical" ? e.scrollY : e.scrollX : t === "vertical" ? e.scrollTop : e.scrollLeft;
+}
+function je(e, t) {
+  const r = ce(e) ? e.document.scrollingElement ?? e.document.documentElement : e;
+  return t === "vertical" ? r.scrollHeight - r.clientHeight : r.scrollWidth - r.clientWidth;
+}
+function ae(e, t) {
+  e && typeof e.scrollTo == "function" && e.scrollTo(t);
+}
+function qe(e, t) {
+  const { overflowX: r, overflowY: o } = Z(e).getComputedStyle(e), s = t === "vertical" ? o : r;
+  return s === "visible" || s === "clip" ? !1 : t === "vertical" ? e.scrollHeight - e.clientHeight > 1 : e.scrollWidth - e.clientWidth > 1;
+}
+function Oe({
+  containerElement: e,
+  direction: t,
+  isRtl: r,
+  scrollTarget: o
+}) {
+  const s = t === "vertical";
+  let i, n;
+  if (ce(o)) {
+    const { documentElement: w } = o.document;
+    i = 0, n = s ? w.clientHeight : w.clientWidth;
+  } else {
+    const w = o.getBoundingClientRect();
+    i = s ? w.top + o.clientTop : w.left + o.clientLeft, n = s ? o.clientHeight : o.clientWidth;
+  }
+  const d = i + n, v = e.getBoundingClientRect(), h = s ? v.top + e.clientTop : v.left + e.clientLeft, f = s ? e.clientHeight : e.clientWidth, u = h + f, a = ne({
+    containerElement: e,
+    direction: t,
+    isRtl: r,
+    scrollOffset: s ? e.scrollTop : e.scrollLeft
+  }), l = !s && r ? u - d : i - h, p = l + n, b = Math.max(0, l), S = Math.min(f, p);
+  return {
+    offset: a + b,
+    size: Math.max(0, S - b),
+    viewportOffset: a + l,
+    viewportSize: n
+  };
+}
+function Ie({
+  direction: e,
+  isRtl: t,
+  scrollTarget: r,
+  viewportSize: o
+}) {
+  const s = ce(r) ? r.document.documentElement : r, i = Z(s).getComputedStyle(s), n = (h) => {
+    const f = parseFloat(h ?? "");
+    return !Number.isFinite(f) || f < 0 ? 0 : h.endsWith("px") ? f : h.endsWith("%") ? f * o / 100 : 0;
+  };
+  if (e === "vertical")
+    return {
+      end: n(i.scrollPaddingBottom),
+      start: n(i.scrollPaddingTop)
+    };
+  const d = n(i.scrollPaddingLeft), v = n(i.scrollPaddingRight);
+  return t ? { end: d, start: v } : { end: v, start: d };
+}
+function Y(e, t = "Assertion error") {
   if (!e)
     throw console.error(t), Error(t);
 }
-function J(e, t) {
+function se(e, t) {
   if (e === t)
     return !0;
-  if (!!e != !!t || ($(e !== void 0), $(t !== void 0), Object.keys(e).length !== Object.keys(t).length))
+  if (!!e != !!t || (Y(e !== void 0), Y(t !== void 0), Object.keys(e).length !== Object.keys(t).length))
     return !1;
-  for (const s in e)
-    if (!Object.hasOwn(t, s) || !Object.is(t[s], e[s]))
+  for (const r in e)
+    if (!Object.hasOwn(t, r) || !Object.is(t[r], e[r]))
       return !1;
   return !0;
 }
-function me({
+function Ve({
   cachedBounds: e,
   itemCount: t,
-  itemSize: s
+  itemSize: r
 }) {
   if (t === 0)
     return 0;
-  if (typeof s == "number")
-    return t * s;
+  if (typeof r == "number")
+    return t * r;
   {
     const o = e.get(
       e.size === 0 ? 0 : e.size - 1
     );
-    $(o !== void 0, "Unexpected bounds cache miss");
-    const r = (o.scrollOffset + o.size) / e.size;
-    return t * r;
+    Y(o !== void 0, "Unexpected bounds cache miss");
+    const s = (o.scrollOffset + o.size) / e.size;
+    return t * s;
   }
 }
-function Ve({
+function Se({
   align: e,
   cachedBounds: t,
-  index: s,
-  itemCount: o,
-  itemSize: r,
+  clamp: r = !0,
+  index: o,
+  itemCount: s,
+  itemSize: i,
   containerScrollOffset: n,
-  containerSize: i
+  containerSize: d
 }) {
-  if (s < 0 || s >= o)
-    throw RangeError(`Invalid index specified: ${s}`, {
-      cause: `Index ${s} is not within the range of 0 - ${o - 1}`
+  if (o < 0 || o >= s)
+    throw RangeError(`Invalid index specified: ${o}`, {
+      cause: `Index ${o} is not within the range of 0 - ${s - 1}`
     });
-  const l = t.get(s), a = me({
+  const v = t.get(o), h = Ve({
     cachedBounds: t,
-    itemCount: o,
-    itemSize: r
-  }), v = Math.max(
-    0,
-    Math.min(a - i, l.scrollOffset)
-  ), f = Math.max(
-    0,
-    l.scrollOffset - i + l.size
-  ), c = l.size > i ? n >= l.scrollOffset && n <= f : n >= f && n <= l.scrollOffset;
+    itemCount: s,
+    itemSize: i
+  }), f = (l) => r ? Math.max(0, Math.min(h - d, l)) : l, u = f(v.scrollOffset), a = r ? Math.max(0, v.scrollOffset - d + v.size) : v.scrollOffset - d + v.size, c = v.size > d ? n >= v.scrollOffset && n <= a : n >= a && n <= v.scrollOffset;
   switch (e === "smart" && (e = c ? "auto" : "center"), e) {
     case "start":
-      return v;
+      return u;
     case "end":
-      return f;
+      return a;
     case "center":
-      return Math.max(
-        0,
-        Math.min(
-          a - i,
-          l.scrollOffset + l.size / 2 - i / 2
-        )
+      return f(
+        v.scrollOffset + v.size / 2 - d / 2
       );
     case "auto":
     default:
-      return c ? n : n < f ? f : v;
+      return c ? n : n < a ? a : u;
   }
 }
-function ce({
+function fe({
   cachedBounds: e,
   containerScrollOffset: t,
-  containerSize: s,
+  containerSize: r,
   itemCount: o,
-  overscanCount: r
+  overscanCount: s
 }) {
-  const n = o - 1;
+  const i = o - 1;
   if (o === 0)
     return {
       startIndexVisible: 0,
@@ -219,1027 +305,1323 @@ function ce({
       startIndexOverscan: 0,
       stopIndexOverscan: -1
     };
-  let i, l;
-  const { itemSize: a } = e;
-  if (a !== void 0)
-    a > 0 ? (i = Math.max(
+  let n, d;
+  const { itemSize: v } = e;
+  if (v !== void 0)
+    v > 0 ? (n = Math.max(
       0,
-      Math.min(n, Math.floor(t / a))
-    ), l = Math.max(
-      i,
+      Math.min(i, Math.floor(t / v))
+    ), d = Math.max(
+      n,
       Math.min(
-        n,
-        Math.ceil((t + s) / a) - 1
+        i,
+        Math.ceil((t + r) / v) - 1
       )
-    )) : (i = 0, l = 0);
+    )) : (n = 0, d = 0);
   else {
-    let v = 0, f = Math.min(n, Math.max(0, e.size - 1));
-    for (; v < f; ) {
-      const c = Math.floor((v + f) / 2), u = e.get(c);
-      u.scrollOffset + u.size > t ? f = c : v = c + 1;
+    let h = 0, f = Math.min(i, Math.max(0, e.size - 1));
+    for (; h < f; ) {
+      const u = Math.floor((h + f) / 2), a = e.get(u);
+      a.scrollOffset + a.size > t ? f = u : h = u + 1;
     }
-    for (; v < n; ) {
-      const c = e.get(v);
-      if (c.scrollOffset + c.size > t) break;
-      v++;
+    for (; h < i; ) {
+      const u = e.get(h);
+      if (u.scrollOffset + u.size > t) break;
+      h++;
     }
-    for (i = v, l = v; l < n; ) {
-      const c = e.get(l);
-      if (c.scrollOffset + c.size >= t + s)
+    for (n = h, d = h; d < i; ) {
+      const u = e.get(d);
+      if (u.scrollOffset + u.size >= t + r)
         break;
-      l++;
+      d++;
     }
   }
   return {
-    startIndexVisible: i,
-    stopIndexVisible: l,
-    startIndexOverscan: Math.max(0, i - r),
-    stopIndexOverscan: Math.min(n, l + r)
+    startIndexVisible: n,
+    stopIndexVisible: d,
+    startIndexOverscan: Math.max(0, n - s),
+    stopIndexOverscan: Math.min(i, d + s)
   };
 }
-function ke({
+function Ge({
   itemCount: e,
   itemProps: t,
-  itemSize: s
+  itemSize: r
 }) {
   const o = /* @__PURE__ */ new Map();
   return {
-    itemSize: typeof s == "number" ? s : void 0,
-    get(r) {
-      if ($(r < e, `Invalid index ${r}`), typeof s == "number")
-        return $(r >= 0, `Invalid index ${r}`), { size: s, scrollOffset: r * s };
-      for (; o.size - 1 < r; ) {
-        const i = o.size, l = s(i, t);
-        if (i === 0)
-          o.set(i, {
-            size: l,
+    itemSize: typeof r == "number" ? r : void 0,
+    get(s) {
+      if (Y(s < e, `Invalid index ${s}`), typeof r == "number")
+        return Y(s >= 0, `Invalid index ${s}`), { size: r, scrollOffset: s * r };
+      for (; o.size - 1 < s; ) {
+        const n = o.size, d = r(n, t);
+        if (n === 0)
+          o.set(n, {
+            size: d,
             scrollOffset: 0
           });
         else {
-          const a = o.get(i - 1);
-          $(
-            a !== void 0,
-            `Unexpected bounds cache miss for index ${r}`
-          ), o.set(i, {
-            scrollOffset: a.scrollOffset + a.size,
-            size: l
+          const v = o.get(n - 1);
+          Y(
+            v !== void 0,
+            `Unexpected bounds cache miss for index ${s}`
+          ), o.set(n, {
+            scrollOffset: v.scrollOffset + v.size,
+            size: d
           });
         }
       }
-      const n = o.get(r);
-      return $(
-        n !== void 0,
-        `Unexpected bounds cache miss for index ${r}`
-      ), n;
+      const i = o.get(s);
+      return Y(
+        i !== void 0,
+        `Unexpected bounds cache miss for index ${s}`
+      ), i;
     },
-    set(r, n) {
-      o.set(r, n);
+    set(s, i) {
+      o.set(s, i);
     },
     get size() {
       return o.size;
     }
   };
 }
-function Fe({
+function Xe({
   itemCount: e,
   itemProps: t,
-  itemSize: s
+  itemSize: r
 }) {
-  return N(
-    () => ke({
+  return q(
+    () => Ge({
       itemCount: e,
       itemProps: t,
-      itemSize: s
+      itemSize: r
     }),
-    [e, t, s]
+    [e, t, r]
   );
 }
-function We({
+function Ye({
   containerSize: e,
   itemSize: t
 }) {
-  let s;
+  let r;
   switch (typeof t) {
     case "string": {
-      $(
+      Y(
         t.endsWith("%"),
         `Invalid item size: "${t}"; string values must be percentages (e.g. "100%")`
-      ), $(
+      ), Y(
         e !== void 0,
         "Container size must be defined if a percentage item size is specified"
-      ), s = e * parseFloat(t) / 100;
+      ), r = e * parseFloat(t) / 100;
       break;
     }
     default: {
-      s = t;
+      r = t;
       break;
     }
   }
-  return typeof s == "number" && !(Number.isFinite(s) && s > 0) && (s = 0), s;
+  return typeof r == "number" && !(Number.isFinite(r) && r > 0) && (r = 0), r;
 }
-function fe({
+function pe({
   containerElement: e,
   containerStyle: t,
-  defaultContainerSize: s = 0,
+  defaultContainerSize: r = 0,
   defaultScrollOffset: o = 0,
-  direction: r,
-  isRtl: n = !1,
-  itemCount: i,
-  itemProps: l,
-  itemSize: a,
-  onResize: v,
-  overscanCount: f
+  direction: s,
+  isRtl: i = !1,
+  itemCount: n,
+  itemProps: d,
+  itemSize: v,
+  onResize: h,
+  overscanCount: f,
+  scrollElement: u
 }) {
-  const { height: c = s, width: u = s } = Le({
-    defaultHeight: r === "vertical" ? s : void 0,
-    defaultWidth: r === "horizontal" ? s : void 0,
+  const a = u !== void 0, c = a ? $e(e, u) : e, { height: l = r, width: p = r } = De({
+    defaultHeight: s === "vertical" ? r : void 0,
+    defaultWidth: s === "horizontal" ? r : void 0,
     element: e,
-    mode: r === "vertical" ? "only-height" : "only-width",
+    mode: s === "vertical" ? "only-height" : "only-width",
     style: t
-  }), p = H({
+  }), b = P({
     height: 0,
     width: 0
-  }), d = r === "vertical" ? c : u, x = We({ containerSize: d, itemSize: a });
-  W(() => {
-    if (typeof v == "function") {
-      const b = p.current;
-      (b.height !== c || b.width !== u) && (v({ height: c, width: u }, { ...b }), b.height = c, b.width = u);
+  }), [S, w] = C(r), m = a ? S : s === "vertical" ? l : p, T = Ye({ containerSize: m, itemSize: v });
+  B(() => {
+    if (typeof h == "function") {
+      const z = b.current;
+      (z.height !== l || z.width !== p) && (h({ height: l, width: p }, { ...z }), z.height = l, z.width = p);
     }
-  }, [c, v, u]);
-  const h = Fe({
-    itemCount: i,
-    itemProps: l,
-    itemSize: x
-  }), O = Ie(), [g] = M(
-    () => O ? 0 : o
-  ), D = U(
-    (b) => h.get(b),
-    [h]
-  ), [z, X] = M(
-    () => ce({
-      cachedBounds: h,
-      containerScrollOffset: g,
-      containerSize: d,
-      itemCount: i,
+  }, [l, h, p]);
+  const g = Xe({
+    itemCount: n,
+    itemProps: d,
+    itemSize: T
+  }), J = We(), [k] = C(
+    () => J || a ? 0 : o
+  ), E = X(
+    (z) => g.get(z),
+    [g]
+  ), [L, $] = C(
+    () => fe({
+      cachedBounds: g,
+      containerScrollOffset: k,
+      containerSize: m,
+      itemCount: n,
       overscanCount: f
     })
   ), {
-    startIndexVisible: L,
-    startIndexOverscan: j,
-    stopIndexVisible: I,
-    stopIndexOverscan: te
+    startIndexVisible: _,
+    startIndexOverscan: Q,
+    stopIndexVisible: te,
+    stopIndexOverscan: R
   } = {
-    startIndexVisible: Math.min(i - 1, z.startIndexVisible),
-    startIndexOverscan: Math.min(i - 1, z.startIndexOverscan),
-    stopIndexVisible: Math.min(i - 1, z.stopIndexVisible),
-    stopIndexOverscan: Math.min(i - 1, z.stopIndexOverscan)
-  }, A = U(
-    () => me({
-      cachedBounds: h,
-      itemCount: i,
-      itemSize: x
+    startIndexVisible: Math.min(n - 1, L.startIndexVisible),
+    startIndexOverscan: Math.min(n - 1, L.startIndexOverscan),
+    stopIndexVisible: Math.min(n - 1, L.stopIndexVisible),
+    stopIndexOverscan: Math.min(n - 1, L.stopIndexOverscan)
+  }, O = X(
+    () => Ve({
+      cachedBounds: g,
+      itemCount: n,
+      itemSize: T
     }),
-    [h, i, x]
-  ), q = U(
-    (b) => {
-      const w = C({
+    [g, n, T]
+  ), H = X(
+    (z) => {
+      const x = ne({
         containerElement: e,
-        direction: r,
-        isRtl: n,
-        scrollOffset: b
+        direction: s,
+        isRtl: i,
+        scrollOffset: z
       });
-      return ce({
-        cachedBounds: h,
-        containerScrollOffset: w,
-        containerSize: d,
-        itemCount: i,
+      return fe({
+        cachedBounds: g,
+        containerScrollOffset: x,
+        containerSize: m,
+        itemCount: n,
         overscanCount: f
       });
     },
     [
-      h,
+      g,
       e,
-      d,
-      r,
-      n,
+      m,
+      s,
       i,
+      n,
       f
     ]
-  ), Q = H(!1);
-  W(() => {
-    if (!e || i === 0 || Q.current || (Q.current = !0, o <= 0))
+  ), I = P(!1);
+  B(() => {
+    if (!e || n === 0 || a || I.current || (I.current = !0, o <= 0))
       return;
-    const b = r === "horizontal" && we(e);
-    if (C({
+    const z = s === "horizontal" && Ae(e);
+    if (ne({
       containerElement: e,
-      direction: r,
-      isRtl: b,
-      scrollOffset: r === "vertical" ? e.scrollTop : e.scrollLeft
+      direction: s,
+      isRtl: z,
+      scrollOffset: s === "vertical" ? e.scrollTop : e.scrollLeft
     }) !== 0)
       return;
-    const y = C({
+    const A = ne({
       containerElement: e,
-      direction: r,
-      isRtl: b,
+      direction: s,
+      isRtl: z,
       scrollOffset: o
     });
     typeof e.scrollTo == "function" ? e.scrollTo({
       behavior: "instant",
-      [r === "vertical" ? "top" : "left"]: y
-    }) : r === "vertical" ? e.scrollTop = y : e.scrollLeft = y;
-  }, [e, i]), W(() => {
-    const b = e ? q(
-      r === "vertical" ? e.scrollTop : e.scrollLeft
-    ) : ce({
-      cachedBounds: h,
-      containerScrollOffset: g,
-      containerSize: d,
-      itemCount: i,
+      [s === "vertical" ? "top" : "left"]: A
+    }) : s === "vertical" ? e.scrollTop = A : e.scrollLeft = A;
+  }, [e, n]), B(() => {
+    if (a && e && c)
+      return;
+    const z = e && !a ? H(
+      s === "vertical" ? e.scrollTop : e.scrollLeft
+    ) : fe({
+      cachedBounds: g,
+      containerScrollOffset: k,
+      containerSize: m,
+      itemCount: n,
       overscanCount: f
     });
-    X((w) => J(b, w) ? w : b);
+    $((x) => se(z, x) ? x : z);
   }, [
-    h,
-    e,
-    d,
-    r,
-    q,
     g,
-    i,
-    f
-  ]), W(() => {
-    if (!e)
+    e,
+    m,
+    s,
+    H,
+    k,
+    a,
+    n,
+    f,
+    c
+  ]), B(() => {
+    if (!e || a)
       return;
-    const b = () => {
-      X((w) => {
-        const { scrollLeft: y, scrollTop: T } = e, E = C({
+    const z = () => {
+      $((x) => {
+        const { scrollLeft: A, scrollTop: N } = e, W = ne({
           containerElement: e,
-          direction: r,
-          isRtl: n,
-          scrollOffset: r === "vertical" ? T : y
-        }), V = ce({
-          cachedBounds: h,
-          containerScrollOffset: E,
-          containerSize: d,
-          itemCount: i,
+          direction: s,
+          isRtl: i,
+          scrollOffset: s === "vertical" ? N : A
+        }), D = fe({
+          cachedBounds: g,
+          containerScrollOffset: W,
+          containerSize: m,
+          itemCount: n,
           overscanCount: f
         });
-        return J(V, w) ? w : V;
+        return se(D, x) ? x : D;
       });
     };
-    return e.addEventListener("scroll", b), () => {
-      e.removeEventListener("scroll", b);
+    return e.addEventListener("scroll", z), () => {
+      e.removeEventListener("scroll", z);
     };
   }, [
-    h,
+    g,
     e,
-    d,
-    r,
-    n,
+    m,
+    s,
     i,
+    a,
+    n,
     f
   ]);
-  const m = ee(
+  const K = ie(() => {
+    if (!e || !c)
+      return;
+    const { offset: z, size: x, viewportSize: A } = Oe({
+      containerElement: e,
+      direction: s,
+      isRtl: i,
+      scrollTarget: c
+    });
+    w(A);
+    const N = fe({
+      cachedBounds: g,
+      containerScrollOffset: z,
+      containerSize: x,
+      itemCount: n,
+      overscanCount: f
+    });
+    $((W) => se(N, W) ? W : N);
+  });
+  B(() => {
+    a && K();
+  }), B(() => {
+    if (!a || !e || !c)
+      return;
+    const z = Z(e), x = () => K();
+    c.addEventListener("scroll", x, { passive: !0 }), e.addEventListener("scroll", x, { passive: !0 }), z.addEventListener("resize", x);
+    let A;
+    const N = we(e);
+    N && !ce(c) && (A = new N(x), A.observe(c));
+    const W = Ce({
+      container: ce(c) ? c.document.documentElement : c,
+      element: e,
+      onChange: x
+    });
+    return () => {
+      c.removeEventListener("scroll", x), e.removeEventListener("scroll", x), z.removeEventListener("resize", x), A?.disconnect(), W();
+    };
+  }, [
+    e,
+    a,
+    c,
+    K
+  ]);
+  const re = ie(
     ({
-      align: b = "auto",
-      containerScrollOffset: w,
-      index: y
+      align: z = "auto",
+      index: x
     }) => {
-      let T = Ve({
-        align: b,
-        cachedBounds: h,
-        containerScrollOffset: C({
+      const A = ({
+        clamp: V,
+        containerScrollOffset: F,
+        containerSize: M,
+        padding: y
+      }) => {
+        if (y.start === 0 && y.end === 0)
+          return Se({
+            align: z,
+            cachedBounds: g,
+            clamp: V,
+            containerScrollOffset: F,
+            containerSize: M,
+            index: x,
+            itemCount: n,
+            itemSize: T
+          });
+        const U = Se({
+          align: z,
+          cachedBounds: g,
+          clamp: !1,
+          containerScrollOffset: F + y.start,
+          containerSize: Math.max(
+            0,
+            M - y.start - y.end
+          ),
+          index: x,
+          itemCount: n,
+          itemSize: T
+        }) - y.start;
+        return V ? Math.max(0, Math.min(O() - M, U)) : U;
+      };
+      if (a && e && c && !qe(e, s)) {
+        const { viewportOffset: V, viewportSize: F } = Oe({
           containerElement: e,
-          direction: r,
-          isRtl: n,
-          scrollOffset: w
+          direction: s,
+          isRtl: i,
+          scrollTarget: c
+        }), y = A({
+          clamp: !1,
+          containerScrollOffset: V,
+          containerSize: F,
+          padding: Ie({
+            direction: s,
+            isRtl: i,
+            scrollTarget: c,
+            viewportSize: F
+          })
+        }) - V, U = s === "horizontal" && i ? -y : y;
+        return {
+          scrollOffset: de(c, s) + U,
+          scrollTarget: c
+        };
+      }
+      const N = e ? s === "vertical" ? e.scrollTop : e.scrollLeft : 0, W = a && e ? s === "vertical" ? e.clientHeight : e.clientWidth : m;
+      let D = A({
+        clamp: !0,
+        containerScrollOffset: ne({
+          containerElement: e,
+          direction: s,
+          isRtl: i,
+          scrollOffset: N
         }),
-        containerSize: d,
-        index: y,
-        itemCount: i,
-        itemSize: x
+        containerSize: W,
+        padding: e ? Ie({
+          direction: s,
+          isRtl: i,
+          scrollTarget: e,
+          viewportSize: W
+        }) : { end: 0, start: 0 }
       });
-      if (e) {
-        if (T = C({
+      if (e && (!a || c)) {
+        if (D = ne({
           containerElement: e,
-          direction: r,
-          isRtl: n,
-          scrollOffset: T
-        }), typeof e.scrollTo != "function") {
-          const E = q(T);
-          J(z, E) || X(E);
+          direction: s,
+          isRtl: i,
+          scrollOffset: D
+        }), !a && typeof e.scrollTo != "function") {
+          const V = H(D);
+          se(L, V) || $(V);
         }
-        return T;
+        return { scrollOffset: D, scrollTarget: e };
       }
     }
   );
   return {
-    getCellBounds: D,
-    getEstimatedSize: A,
-    scrollToIndex: m,
-    startIndexOverscan: j,
-    startIndexVisible: L,
-    stopIndexOverscan: te,
-    stopIndexVisible: I
+    getCellBounds: E,
+    getEstimatedSize: O,
+    getScrollPositionForIndex: re,
+    scrollTarget: c,
+    startIndexOverscan: Q,
+    startIndexVisible: _,
+    stopIndexOverscan: R,
+    stopIndexVisible: te
   };
 }
-function ze(e) {
-  const [t, s] = M(e);
-  return J(t, e) ? t : (s(e), e);
+function Fe(e) {
+  const [t, r] = C(e);
+  return se(t, e) ? t : (r(e), e);
 }
-function ye(e, t) {
+function He(e, t) {
   const {
-    ariaAttributes: s,
+    ariaAttributes: r,
     style: o,
-    ...r
+    ...s
   } = e, {
-    ariaAttributes: n,
-    style: i,
-    ...l
+    ariaAttributes: i,
+    style: n,
+    ...d
   } = t;
-  return J(s, n) && J(o, i) && J(r, l);
+  return se(r, i) && se(o, n) && se(s, d);
 }
-function Ne({
+function rt({
   cellComponent: e,
   cellProps: t,
-  children: s,
+  children: r,
   className: o,
-  columnCount: r,
-  columnKey: n,
-  columnWidth: i,
-  defaultHeight: l = 0,
-  defaultScrollLeft: a = 0,
-  defaultScrollTop: v = 0,
+  columnCount: s,
+  columnKey: i,
+  columnWidth: n,
+  defaultHeight: d = 0,
+  defaultScrollLeft: v = 0,
+  defaultScrollTop: h = 0,
   defaultWidth: f = 0,
-  dir: c,
-  gridRef: u,
-  onCellsRendered: p,
-  onResize: d,
-  overscanCount: x = 3,
-  rowCount: h,
-  rowHeight: O,
-  rowKey: g,
-  style: D,
-  tagName: z = "div",
-  ...X
+  dir: u,
+  gridRef: a,
+  onCellsRendered: c,
+  onResize: l,
+  overscanCount: p = 3,
+  rowCount: b,
+  rowHeight: S,
+  rowKey: w,
+  scrollElement: m,
+  style: T,
+  tagName: g = "div",
+  ...J
 }) {
-  const L = ze(t), j = N(
-    () => ge(e, ye),
+  const k = Fe(t), E = q(
+    () => Le(e, He),
     [e]
-  ), [I, te] = M(null), A = Ae(I, c), {
-    getCellBounds: q,
-    getEstimatedSize: Q,
-    startIndexOverscan: m,
-    startIndexVisible: b,
-    scrollToIndex: w,
-    stopIndexOverscan: y,
-    stopIndexVisible: T
-  } = fe({
-    containerElement: I,
-    containerStyle: D,
+  ), [L, $] = C(null), _ = Ee(L, u), {
+    getCellBounds: Q,
+    getEstimatedSize: te,
+    startIndexOverscan: R,
+    startIndexVisible: O,
+    getScrollPositionForIndex: H,
+    stopIndexOverscan: I,
+    stopIndexVisible: K
+  } = pe({
+    containerElement: L,
+    containerStyle: T,
     defaultContainerSize: f,
-    defaultScrollOffset: a,
+    defaultScrollOffset: v,
     direction: "horizontal",
-    isRtl: A,
-    itemCount: r,
-    itemProps: L,
-    itemSize: i,
-    onResize: d,
-    overscanCount: x
+    isRtl: _,
+    itemCount: s,
+    itemProps: k,
+    itemSize: n,
+    onResize: l,
+    overscanCount: p,
+    scrollElement: m
   }), {
-    getCellBounds: E,
-    getEstimatedSize: V,
-    startIndexOverscan: Z,
-    startIndexVisible: ne,
-    scrollToIndex: K,
-    stopIndexOverscan: G,
-    stopIndexVisible: k
-  } = fe({
-    containerElement: I,
-    containerStyle: D,
-    defaultContainerSize: l,
-    defaultScrollOffset: v,
+    getCellBounds: re,
+    getEstimatedSize: z,
+    startIndexOverscan: x,
+    startIndexVisible: A,
+    getScrollPositionForIndex: N,
+    stopIndexOverscan: W,
+    stopIndexVisible: D
+  } = pe({
+    containerElement: L,
+    containerStyle: T,
+    defaultContainerSize: d,
+    defaultScrollOffset: h,
     direction: "vertical",
-    itemCount: h,
-    itemProps: L,
-    itemSize: O,
-    onResize: d,
-    overscanCount: x
+    itemCount: b,
+    itemProps: k,
+    itemSize: S,
+    onResize: l,
+    overscanCount: p,
+    scrollElement: m
   });
-  xe(
-    u,
+  Me(
+    a,
     () => ({
       get element() {
-        return I;
+        return L;
       },
       scrollToCell({
-        behavior: F = "auto",
-        columnAlign: S = "auto",
-        columnIndex: _,
-        rowAlign: Y = "auto",
-        rowIndex: B
+        behavior: M = "auto",
+        columnAlign: y = "auto",
+        columnIndex: U,
+        rowAlign: j = "auto",
+        rowIndex: ee
       }) {
-        const se = w({
-          align: S,
-          containerScrollOffset: I?.scrollLeft ?? 0,
-          index: _
-        }), Se = K({
-          align: Y,
-          containerScrollOffset: I?.scrollTop ?? 0,
-          index: B
-        });
-        typeof I?.scrollTo == "function" && I.scrollTo({
-          behavior: F,
-          left: se,
-          top: Se
+        const G = H({
+          align: y,
+          index: U
+        }), oe = N({
+          align: j,
+          index: ee
         });
+        G && oe && G.scrollTarget === oe.scrollTarget ? ae(oe.scrollTarget, {
+          behavior: M,
+          left: G.scrollOffset,
+          top: oe.scrollOffset
+        }) : (G && ae(G.scrollTarget, {
+          behavior: M,
+          left: G.scrollOffset
+        }), oe && ae(oe.scrollTarget, {
+          behavior: M,
+          top: oe.scrollOffset
+        }));
       },
       scrollToColumn({
-        align: F = "auto",
-        behavior: S = "auto",
-        index: _
+        align: M = "auto",
+        behavior: y = "auto",
+        index: U
       }) {
-        const Y = w({
-          align: F,
-          containerScrollOffset: I?.scrollLeft ?? 0,
-          index: _
-        });
-        typeof I?.scrollTo == "function" && I.scrollTo({
-          behavior: S,
-          left: Y
+        const j = H({ align: M, index: U });
+        j && ae(j.scrollTarget, {
+          behavior: y,
+          left: j.scrollOffset
         });
       },
       scrollToRow({
-        align: F = "auto",
-        behavior: S = "auto",
-        index: _
+        align: M = "auto",
+        behavior: y = "auto",
+        index: U
       }) {
-        const Y = K({
-          align: F,
-          containerScrollOffset: I?.scrollTop ?? 0,
-          index: _
-        });
-        typeof I?.scrollTo == "function" && I.scrollTo({
-          behavior: S,
-          top: Y
+        const j = N({ align: M, index: U });
+        j && ae(j.scrollTarget, {
+          behavior: y,
+          top: j.scrollOffset
         });
       }
     }),
-    [I, w, K]
-  ), ie(() => {
-    m >= 0 && y >= 0 && Z >= 0 && G >= 0 && p && p(
+    [L, H, N]
+  ), le(() => {
+    R >= 0 && I >= 0 && x >= 0 && W >= 0 && c && c(
       {
-        columnStartIndex: b,
-        columnStopIndex: T,
-        rowStartIndex: ne,
-        rowStopIndex: k
+        columnStartIndex: O,
+        columnStopIndex: K,
+        rowStartIndex: A,
+        rowStopIndex: D
       },
       {
-        columnStartIndex: m,
-        columnStopIndex: y,
-        rowStartIndex: Z,
-        rowStopIndex: G
+        columnStartIndex: R,
+        columnStopIndex: I,
+        rowStartIndex: x,
+        rowStopIndex: W
       }
     );
   }, [
-    p,
-    m,
-    b,
-    y,
-    T,
-    Z,
-    ne,
-    G,
-    k
+    c,
+    R,
+    O,
+    I,
+    K,
+    x,
+    A,
+    W,
+    D
   ]);
-  const R = N(() => {
-    const F = [];
-    if (r > 0 && h > 0)
-      for (let S = Z; S <= G; S++) {
-        const _ = E(S), Y = [];
-        for (let B = m; B <= y; B++) {
-          const se = q(B);
-          Y.push(
-            /* @__PURE__ */ le(
-              j,
+  const V = q(() => {
+    const M = [];
+    if (s > 0 && b > 0)
+      for (let y = x; y <= W; y++) {
+        const U = re(y), j = [];
+        for (let ee = R; ee <= I; ee++) {
+          const G = Q(ee);
+          j.push(
+            /* @__PURE__ */ he(
+              E,
               {
-                ...L,
+                ...k,
                 ariaAttributes: {
-                  "aria-colindex": B + 1,
+                  "aria-colindex": ee + 1,
                   role: "gridcell"
                 },
-                columnIndex: B,
-                key: n ? n({
-                  columnIndex: B,
-                  data: L,
-                  rowIndex: S
-                }) : B,
-                rowIndex: S,
+                columnIndex: ee,
+                key: i ? i({
+                  columnIndex: ee,
+                  data: k,
+                  rowIndex: y
+                }) : ee,
+                rowIndex: y,
                 style: {
                   position: "absolute",
-                  left: A ? void 0 : 0,
-                  right: A ? 0 : void 0,
-                  transform: `translate(${A ? -se.scrollOffset : se.scrollOffset}px, ${_.scrollOffset}px)`,
-                  height: _.size,
-                  width: se.size
+                  left: _ ? void 0 : 0,
+                  right: _ ? 0 : void 0,
+                  transform: `translate(${_ ? -G.scrollOffset : G.scrollOffset}px, ${U.scrollOffset}px)`,
+                  height: U.size,
+                  width: G.size
                 }
               }
             )
           );
         }
-        F.push(
-          /* @__PURE__ */ re(
+        M.push(
+          /* @__PURE__ */ ue(
             "div",
             {
               role: "row",
-              "aria-rowindex": S + 1,
-              children: Y
+              "aria-rowindex": y + 1,
+              children: j
             },
-            g ? g({
-              data: L,
-              rowIndex: S
-            }) : S
+            w ? w({
+              data: k,
+              rowIndex: y
+            }) : y
           )
         );
       }
-    return F;
+    return M;
   }, [
-    j,
-    L,
-    r,
-    n,
-    m,
-    y,
-    q,
     E,
-    A,
-    h,
-    g,
-    Z,
-    G
-  ]), P = /* @__PURE__ */ re(
+    k,
+    s,
+    i,
+    R,
+    I,
+    Q,
+    re,
+    _,
+    b,
+    w,
+    x,
+    W
+  ]), F = /* @__PURE__ */ ue(
     "div",
     {
       "aria-hidden": !0,
       style: {
-        height: V(),
-        width: Q(),
+        height: z(),
+        width: te(),
         zIndex: -1
       }
     }
   );
-  return le(
-    z,
+  return he(
+    g,
     {
-      "aria-colcount": r,
-      "aria-rowcount": h,
+      "aria-colcount": s,
+      "aria-rowcount": b,
       role: "grid",
-      ...X,
+      ...J,
       className: o,
-      dir: c,
-      ref: te,
+      dir: u,
+      ref: $,
       style: {
         position: "relative",
-        maxHeight: "100%",
-        maxWidth: "100%",
+        // Grids that scroll with an outer element render at their full height,
+        // and at their full width unless constrained by their parent (in which case columns scroll within the grid)
+        ...m === void 0 && {
+          maxHeight: "100%",
+          maxWidth: "100%"
+        },
         flexGrow: 1,
         overflow: "auto",
-        ...D
+        ...T
       }
     },
-    R,
-    s,
-    P
+    V,
+    r,
+    F
   );
 }
-const qe = M, Ge = H;
-function $e({
-  callback: e,
-  element: t,
-  enabled: s = !0
-}) {
-  const o = ee(e);
-  ie(() => {
-    if (!s || !t)
-      return;
-    const r = ae(t);
-    let n = r.requestAnimationFrame(() => {
-      n = r.requestAnimationFrame(o);
-    });
-    return () => {
-      r.cancelAnimationFrame(n);
-    };
-  }, [t, s, o]);
+const ot = C, nt = P, ke = "data-react-window-index", Ze = "data-index";
+function ge(e) {
+  const t = e.getAttribute(ke) ?? e.getAttribute(Ze);
+  return t !== null && /^\d+$/.test(t) ? Number(t) : void 0;
 }
-function He(e) {
-  return e != null && typeof e == "object" && "getAverageRowHeight" in e && typeof e.getAverageRowHeight == "function";
+const Je = 1e3, ze = 500;
+function Qe(e) {
+  return 1 - Math.pow(1 - e, 3);
 }
-function je({
-  element: e,
-  getCellBounds: t,
-  isDynamicRowHeight: s,
-  rowCount: o,
-  rowElements: r,
-  scrollToIndex: n
+function Ne({
+  direction: e,
+  element: t,
+  getCellBounds: r,
+  isDynamicSize: o,
+  itemCount: s,
+  itemElements: i,
+  scrollTarget: n,
+  getScrollPositionForIndex: d
 }) {
-  const i = H(null), l = H(
+  const v = e === "vertical", h = P(null), f = P(
     void 0
-  ), a = ee(() => {
-    i.current = null, l.current !== void 0 && (l.current.view.cancelAnimationFrame(l.current.id), l.current = void 0);
-  }), v = ee(() => {
-    const c = ae(e);
-    l.current = {
-      id: c.requestAnimationFrame(f),
-      view: c
+  ), u = ie(() => {
+    h.current = null, f.current !== void 0 && (f.current.view.cancelAnimationFrame(f.current.id), f.current = void 0);
+  }), a = ie(() => {
+    const l = Z(t);
+    f.current = {
+      id: l.requestAnimationFrame(c),
+      view: l
     };
-  }), f = ee(() => {
-    l.current = void 0;
-    const c = i.current;
-    if (!c) return;
-    if (!e || !s || c.index >= o || performance.now() >= c.deadline) {
-      a();
+  }), c = ie(() => {
+    f.current = void 0;
+    const l = h.current;
+    if (!l) return;
+    const p = performance.now();
+    if (!t || !o || l.index >= s || l.animation !== void 0 && p >= l.animation.deadline) {
+      u();
       return;
     }
-    const u = n({
-      align: c.align,
-      containerScrollOffset: e.scrollTop,
-      index: c.index
+    const b = d({
+      align: l.align,
+      index: l.index
     });
-    if (u !== void 0) {
-      const p = Math.max(
+    if (b !== void 0) {
+      const { scrollOffset: S, scrollTarget: w } = b, m = Math.max(
         0,
-        Math.min(u, e.scrollHeight - e.clientHeight)
+        Math.min(S, je(w, e))
       );
-      if (Math.abs(p - e.scrollTop) > 1)
-        c.stableFrames = 0, e.scrollTo({ behavior: "instant", top: p });
+      if (l.animation === void 0) {
+        const g = l.smooth ? ze : 0;
+        l.animation = {
+          deadline: p + g + Je,
+          startOffset: de(w, e),
+          startTime: p
+        };
+      }
+      const T = l.smooth ? (p - l.animation.startTime) / ze : 1;
+      if (T < 1) {
+        const { startOffset: g } = l.animation;
+        l.stableFrames = 0, w.scrollTo({
+          behavior: "instant",
+          [v ? "top" : "left"]: g + (m - g) * Qe(T)
+        });
+      } else if (Math.abs(m - de(w, e)) > 1)
+        l.stableFrames = 0, w.scrollTo({
+          behavior: "instant",
+          [v ? "top" : "left"]: m
+        });
       else {
-        const d = r.current;
-        if (!(d.some(
-          (O) => O.getAttribute(oe) === `${c.index}`
-        ) && d.every((O) => {
-          const g = Number(O.getAttribute(oe));
-          return Math.abs(
-            t(g).size - O.offsetHeight
-          ) <= 1;
+        const g = i.current;
+        if (!(g.some(
+          (E) => ge(E) === l.index
+        ) && g.every((E) => {
+          const L = ge(E);
+          if (L === void 0 || L >= s)
+            return !0;
+          const $ = v ? E.offsetHeight : E.offsetWidth;
+          return Math.abs(r(L).size - $) <= 1;
         })))
-          c.stableFrames = 0;
-        else if (++c.stableFrames >= 2) {
-          a();
+          l.stableFrames = 0;
+        else if (++l.stableFrames >= 2) {
+          u();
           return;
         }
       }
     }
-    v();
+    a();
   });
-  return W(() => {
-    if (!e) return;
-    const c = (u) => {
-      switch (u.key) {
+  return B(() => {
+    const l = n ?? t;
+    if (!l) return;
+    const p = (b) => {
+      switch (b.key) {
         case "ArrowUp":
         case "ArrowDown":
+        case "ArrowLeft":
+        case "ArrowRight":
         case "PageUp":
         case "PageDown":
         case "Home":
         case "End":
         case " ":
-          a();
+          u();
       }
     };
-    return e.addEventListener("wheel", a, { passive: !0 }), e.addEventListener("touchstart", a, { passive: !0 }), e.addEventListener("pointerdown", a), e.addEventListener("keydown", c), () => {
-      a(), e.removeEventListener("wheel", a), e.removeEventListener("touchstart", a), e.removeEventListener("pointerdown", a), e.removeEventListener("keydown", c);
+    return l.addEventListener("wheel", u, { passive: !0 }), l.addEventListener("touchstart", u, { passive: !0 }), l.addEventListener("pointerdown", u), l.addEventListener("keydown", p), () => {
+      u(), l.removeEventListener("wheel", u), l.removeEventListener("touchstart", u), l.removeEventListener("pointerdown", u), l.removeEventListener("keydown", p);
     };
-  }, [a, e]), U(
+  }, [u, t, n]), X(
     ({
-      align: c = "auto",
-      behavior: u = "auto",
-      index: p
+      align: l = "auto",
+      behavior: p = "auto",
+      index: b
     }) => {
-      s && c === "smart" && (c = n({
-        align: "auto",
-        containerScrollOffset: e?.scrollTop ?? 0,
-        index: p
-      }) === (e?.scrollTop ?? 0) ? "auto" : "center");
-      const d = n({
-        align: c,
-        containerScrollOffset: e?.scrollTop ?? 0,
-        index: p
-      });
-      a(), typeof e?.scrollTo == "function" && (s && (i.current = {
-        align: c,
-        index: p,
-        deadline: performance.now() + 1e3,
-        stableFrames: 0
-      }, v()), e.scrollTo({
-        behavior: s ? "instant" : u,
-        top: d
-      }));
+      if (o && l === "smart") {
+        const w = d({ align: "auto", index: b });
+        l = w === void 0 || w.scrollOffset === de(w.scrollTarget, e) ? "auto" : "center";
+      }
+      const S = d({ align: l, index: b });
+      if (u(), S && typeof S.scrollTarget.scrollTo == "function") {
+        const { scrollOffset: w, scrollTarget: m } = S;
+        if (o) {
+          const T = p === "smooth" && t?.ownerDocument.visibilityState !== "hidden";
+          if (h.current = {
+            align: l,
+            index: b,
+            smooth: T,
+            stableFrames: 0
+          }, a(), T)
+            return;
+        }
+        m.scrollTo({
+          behavior: o ? "instant" : p,
+          [v ? "top" : "left"]: w
+        });
+      }
     },
     [
-      a,
+      u,
       e,
-      s,
+      t,
+      o,
       v,
-      n
+      a,
+      d
     ]
   );
 }
-const oe = "data-react-window-index", ve = "data-react-window-sizer";
-function _e({
+function Ke({
+  callback: e,
+  element: t,
+  enabled: r = !0
+}) {
+  const o = ie(e);
+  le(() => {
+    if (!r || !t)
+      return;
+    const s = Z(t);
+    let i = s.requestAnimationFrame(() => {
+      i = s.requestAnimationFrame(o);
+    });
+    return () => {
+      s.cancelAnimationFrame(i);
+    };
+  }, [t, r, o]);
+}
+function ve(e) {
+  return e != null && typeof e == "object" && "getAverageRowHeight" in e && typeof e.getAverageRowHeight == "function";
+}
+const ye = "data-react-window-sizer";
+function it({
   children: e,
   className: t,
-  defaultHeight: s = 0,
+  defaultHeight: r = 0,
   defaultScrollOffset: o = 0,
-  listRef: r,
-  onResize: n,
-  onRowsRendered: i,
-  overscanCount: l = 3,
-  rowComponent: a,
-  rowCount: v,
+  listRef: s,
+  onResize: i,
+  onRowsRendered: n,
+  overscanCount: d = 3,
+  rowComponent: v,
+  rowCount: h,
   rowHeight: f,
-  rowKey: c,
-  rowProps: u,
-  tagName: p = "div",
-  style: d,
-  ...x
+  rowKey: u,
+  rowProps: a,
+  scrollElement: c,
+  tagName: l = "div",
+  style: p,
+  ...b
 }) {
-  const h = ze(u), O = N(
-    () => ge(a, ye),
-    [a]
-  ), [g, D] = M(null), z = He(f), X = N(() => z ? (k) => f.getRowHeight(k) ?? f.getAverageRowHeight() : f, [z, f]), L = Ie(), [j, I] = M(
-    () => L && z
-  ), te = H(f);
-  W(() => {
-    j && te.current !== f && I(!1);
-  }, [j, f]), $e({
-    callback: () => I(!1),
-    element: g,
-    enabled: j
+  const S = Fe(a), w = q(
+    () => Le(v, He),
+    [v]
+  ), [m, T] = C(null), g = ve(f), J = q(() => g ? (V) => f.getRowHeight(V) ?? f.getAverageRowHeight() : f, [g, f]), k = We(), [E, L] = C(
+    () => k && g
+  ), $ = P(f);
+  B(() => {
+    E && $.current !== f && L(!1);
+  }, [E, f]), Ke({
+    callback: () => L(!1),
+    element: m,
+    enabled: E
   });
   const {
-    getCellBounds: A,
-    getEstimatedSize: q,
-    scrollToIndex: Q,
-    startIndexOverscan: m,
-    startIndexVisible: b,
-    stopIndexOverscan: w,
-    stopIndexVisible: y
-  } = fe({
-    containerElement: g,
-    containerStyle: d,
-    defaultContainerSize: s,
+    getCellBounds: _,
+    getEstimatedSize: Q,
+    scrollTarget: te,
+    getScrollPositionForIndex: R,
+    startIndexOverscan: O,
+    startIndexVisible: H,
+    stopIndexOverscan: I,
+    stopIndexVisible: K
+  } = pe({
+    containerElement: m,
+    containerStyle: p,
+    defaultContainerSize: r,
     defaultScrollOffset: o,
     direction: "vertical",
-    itemCount: v,
-    itemProps: h,
-    itemSize: X,
-    onResize: n,
-    overscanCount: l
-  }), T = H([]), E = je({
-    element: g,
-    getCellBounds: A,
-    isDynamicRowHeight: z,
-    rowCount: v,
-    rowElements: T,
-    scrollToIndex: Q
+    itemCount: h,
+    itemProps: S,
+    itemSize: J,
+    onResize: i,
+    overscanCount: d,
+    scrollElement: c
+  }), re = P([]), z = Ne({
+    direction: "vertical",
+    element: m,
+    getCellBounds: _,
+    isDynamicSize: g,
+    itemCount: h,
+    itemElements: re,
+    scrollTarget: te,
+    getScrollPositionForIndex: R
   });
-  xe(
-    r,
+  Me(
+    s,
     () => ({
       get element() {
-        return g;
+        return m;
       },
-      scrollToRow: E
+      scrollToRow: z
     }),
-    [g, E]
-  ), W(() => {
-    if (!g)
+    [m, z]
+  ), B(() => {
+    if (!m)
       return;
-    const k = Array.from(g.children).slice(
+    const V = Array.from(m.children).slice(
       0,
-      m < 0 ? 0 : w - m + 1
-    ).filter((R, P) => {
-      if (R.hasAttribute(ve))
+      O < 0 ? 0 : I - O + 1
+    ).filter((F, M) => {
+      if (F.hasAttribute(ye))
         return !1;
-      const F = `${m + P}`;
-      return R.setAttribute(oe, F), !0;
+      const y = `${O + M}`;
+      return F.setAttribute(ke, y), !0;
     });
-    if (T.current = k, z)
-      return f.observeRowElements(k);
+    if (re.current = V, g)
+      return f.observeRowElements(V);
   }, [
-    O,
+    w,
+    m,
     g,
-    z,
-    v,
-    f,
-    c,
     h,
-    m,
-    w
-  ]), ie(() => {
-    m >= 0 && w >= 0 && i && i(
+    f,
+    u,
+    S,
+    O,
+    I
+  ]), le(() => {
+    O >= 0 && I >= 0 && n && n(
       {
-        startIndex: b,
-        stopIndex: y
+        startIndex: H,
+        stopIndex: K
       },
       {
-        startIndex: m,
-        stopIndex: w
+        startIndex: O,
+        stopIndex: I
       }
     );
   }, [
-    i,
-    m,
-    b,
-    w,
-    y
+    n,
+    O,
+    H,
+    I,
+    K
   ]);
-  const V = j && z && m === 0, Z = N(() => {
-    const k = [];
-    if (v > 0)
-      for (let R = m; R <= w; R++) {
-        const P = A(R);
-        k.push(
-          /* @__PURE__ */ le(
-            O,
+  const x = E && g && O === 0, A = q(() => {
+    const V = [];
+    if (h > 0)
+      for (let F = O; F <= I; F++) {
+        const M = _(F);
+        V.push(
+          /* @__PURE__ */ he(
+            w,
             {
-              ...h,
+              ...S,
               ariaAttributes: {
-                "aria-posinset": R + 1,
-                "aria-setsize": v,
+                "aria-posinset": F + 1,
+                "aria-setsize": h,
                 role: "listitem"
               },
-              key: c ? c(R, h) : R,
-              index: R,
-              style: V ? { width: "100%" } : {
+              key: u ? u(F, S) : F,
+              index: F,
+              style: x ? { width: "100%" } : {
                 position: "absolute",
                 left: 0,
-                transform: `translateY(${P.scrollOffset}px)`,
+                transform: `translateY(${M.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: z ? void 0 : P.size,
+                height: g ? void 0 : M.size,
                 width: "100%"
               }
             }
           )
         );
       }
-    return k;
+    return V;
   }, [
-    O,
-    A,
-    z,
-    V,
-    v,
-    c,
+    w,
+    _,
+    g,
+    x,
     h,
-    m,
-    w
-  ]), ne = /* @__PURE__ */ re(
+    u,
+    S,
+    O,
+    I
+  ]), N = /* @__PURE__ */ ue(
     "div",
     {
       "aria-hidden": !0,
-      [ve]: "",
+      [ye]: "",
       style: {
         // Rows rendered in flow layout already take up space
-        position: V ? "absolute" : void 0,
-        top: V ? 0 : void 0,
-        height: q(),
+        position: x ? "absolute" : void 0,
+        top: x ? 0 : void 0,
+        height: Q(),
         width: "100%",
         zIndex: -1
       }
     },
     "sizer"
-  ), K = /* @__PURE__ */ re(ue, { children: e }, "children"), G = /* @__PURE__ */ re(ue, { children: Z }, "rows");
-  return le(
-    p,
+  ), W = /* @__PURE__ */ ue(be, { children: e }, "children"), D = /* @__PURE__ */ ue(be, { children: A }, "rows");
+  return he(
+    l,
     {
       role: "list",
-      ...x,
+      ...b,
       className: t,
-      ref: D,
+      ref: T,
       style: {
         position: "relative",
-        maxHeight: "100%",
         flexGrow: 1,
-        overflowY: "auto",
-        ...d
+        // Lists that scroll with an outer element render at their full height (and must not clip sticky rows)
+        ...c === void 0 && {
+          maxHeight: "100%",
+          overflowY: "auto"
+        },
+        ...p
       }
     },
-    ...V ? [K, G] : [G, K],
-    ne
+    ...x ? [W, D] : [D, W],
+    N
   );
 }
-function pe(e) {
+function Re(e) {
   const t = /* @__PURE__ */ new Map();
-  return e !== void 0 && e.forEach((s, o) => {
-    Number.isFinite(s) && s > 0 && t.set(o, s);
+  return e !== void 0 && e.forEach((r, o) => {
+    Number.isFinite(r) && r > 0 && t.set(o, r);
   }), t;
 }
-function Ye({
+function lt({
   defaultRowHeight: e,
   initialRowHeights: t,
-  key: s
+  key: r
 }) {
-  const [o, r] = M(() => ({
-    key: s,
-    map: pe(t)
+  const [o, s] = C(() => ({
+    key: r,
+    map: Re(t)
   }));
-  o.key !== s && r({
-    key: s,
-    map: pe(t)
+  o.key !== r && s({
+    key: r,
+    map: Re(t)
   });
-  const { map: n } = o, i = U(() => {
-    let u = 0;
-    return n.forEach((p) => {
-      u += p;
-    }), u === 0 ? e : u / n.size;
-  }, [e, n]), l = U(
-    (u) => {
-      const p = n.get(u);
-      return p !== void 0 ? p : e;
+  const { map: i } = o, n = X(() => {
+    let a = 0;
+    return i.forEach((c) => {
+      a += c;
+    }), a === 0 ? e : a / i.size;
+  }, [e, i]), d = X(
+    (a) => {
+      const c = i.get(a);
+      return c !== void 0 ? c : e;
     },
-    [e, n]
-  ), a = U((u, p) => {
-    r((d) => {
-      if (d.map.get(u) === p)
-        return d;
-      const x = new Map(d.map);
-      return x.set(u, p), {
-        ...d,
-        map: x
+    [e, i]
+  ), v = X((a, c) => {
+    s((l) => {
+      if (l.map.get(a) === c)
+        return l;
+      const p = new Map(l.map);
+      return p.set(a, c), {
+        ...l,
+        map: p
       };
     });
-  }, []), v = ee(
-    (u) => {
-      u.length !== 0 && u.forEach((p) => {
-        const { borderBoxSize: d, target: x } = p, h = x.getAttribute(oe);
-        $(
-          h !== null,
-          `Invalid ${oe} attribute value`
-        );
-        const O = parseInt(h), { blockSize: g } = d[0];
-        g && a(O, g);
+  }, []), h = ie(
+    (a) => {
+      a.length !== 0 && a.forEach((c) => {
+        const { borderBoxSize: l, target: p } = c, b = ge(p);
+        if (b === void 0)
+          return;
+        const { blockSize: S } = l[0];
+        S && v(b, S);
       });
     }
-  ), f = H(null);
-  ie(
+  ), f = P(null);
+  le(
     () => () => {
       f.current?.resizeObserver.disconnect(), f.current = null;
     },
     []
   );
-  const c = U(
-    (u) => {
-      const p = [];
-      return u.forEach((d) => {
-        const x = ae(d);
-        if (f.current?.view !== x) {
+  const u = X(
+    (a) => {
+      const c = [];
+      return a.forEach((l) => {
+        const p = Z(l);
+        if (f.current?.view !== p) {
           f.current?.resizeObserver.disconnect();
-          const O = Oe(d);
-          f.current = O ? {
-            resizeObserver: new O(v),
-            view: x
+          const S = we(l);
+          f.current = S ? {
+            resizeObserver: new S(h),
+            view: p
           } : null;
         }
-        const h = f.current?.resizeObserver;
-        h && (h.observe(d), p.push([d, h]));
+        const b = f.current?.resizeObserver;
+        b && (b.observe(l), c.push([l, b]));
       }), () => {
-        p.forEach(
-          ([d, x]) => x.unobserve(d)
+        c.forEach(
+          ([l, p]) => p.unobserve(l)
         );
       };
     },
-    [v]
+    [h]
   );
-  return N(
+  return q(
     () => ({
-      getAverageRowHeight: i,
-      getRowHeight: l,
-      setRowHeight: a,
-      observeRowElements: c
+      getAverageRowHeight: n,
+      getRowHeight: d,
+      setRowHeight: v,
+      observeRowElements: u
     }),
-    [i, l, a, c]
+    [n, d, v, u]
+  );
+}
+const ct = C, at = P, et = {};
+function ft({
+  count: e,
+  defaultScrollOffset: t = 0,
+  defaultSize: r = 0,
+  dir: o,
+  direction: s = "vertical",
+  element: i,
+  itemSize: n,
+  onItemsRendered: d,
+  overscanCount: v = 3,
+  scrollElement: h
+}) {
+  const f = ve(n);
+  Y(
+    !f || s === "vertical",
+    "Dynamic item sizes are only supported for vertical content"
   );
+  const u = q(() => ve(n) ? (R) => n.getRowHeight(R) ?? n.getAverageRowHeight() : n, [n]), a = Ee(i, o), {
+    getCellBounds: c,
+    getEstimatedSize: l,
+    scrollTarget: p,
+    getScrollPositionForIndex: b,
+    startIndexOverscan: S,
+    startIndexVisible: w,
+    stopIndexOverscan: m,
+    stopIndexVisible: T
+  } = pe({
+    containerElement: i,
+    defaultContainerSize: r,
+    defaultScrollOffset: t,
+    direction: s,
+    isRtl: s === "horizontal" && a,
+    itemCount: e,
+    itemProps: et,
+    itemSize: u,
+    onResize: void 0,
+    overscanCount: v,
+    scrollElement: h
+  }), g = P(/* @__PURE__ */ new Set()), J = P(/* @__PURE__ */ new WeakSet()), k = P([]), E = P({ dynamicRowHeight: null, unobserve: /* @__PURE__ */ new Map() }), L = X((R) => {
+    R !== null && g.current.add(R);
+  }, []), $ = i;
+  B(() => {
+    const R = g.current, O = E.current, H = ve(n) ? n : null;
+    O.dynamicRowHeight?.observeRowElements !== H?.observeRowElements && (O.unobserve.forEach((I) => I()), O.unobserve.clear()), O.dynamicRowHeight = H, R.forEach((I) => {
+      if (!I.isConnected)
+        R.delete(I), O.unobserve.get(I)?.(), O.unobserve.delete(I);
+      else if (H && // Like List, measure items once the element has mounted
+      // (e.g. so the dynamic row height cache has finished mounting too)
+      $ !== null && !O.unobserve.has(I)) {
+        if (ge(I) === void 0) {
+          J.current.has(I) || (J.current.add(I), console.warn(
+            "useVirtualizer: Items passed to measureElement must specify their index with a data-index attribute",
+            I
+          ));
+          return;
+        }
+        O.unobserve.set(
+          I,
+          H.observeRowElements([I])
+        );
+      }
+    }), k.current = Array.from(R);
+  }), le(() => {
+    const R = E.current;
+    return () => {
+      R.unobserve.forEach((O) => O()), R.unobserve.clear(), R.dynamicRowHeight = null;
+    };
+  }, []);
+  const _ = Ne({
+    direction: s,
+    element: i,
+    getCellBounds: c,
+    isDynamicSize: f,
+    itemCount: e,
+    itemElements: k,
+    scrollTarget: p,
+    getScrollPositionForIndex: b
+  });
+  le(() => {
+    S >= 0 && m >= 0 && d && d(
+      { startIndex: w, stopIndex: T },
+      { startIndex: S, stopIndex: m }
+    );
+  }, [
+    d,
+    S,
+    w,
+    m,
+    T
+  ]);
+  const Q = q(() => {
+    const R = [];
+    if (e > 0)
+      for (let O = S; O <= m; O++) {
+        const { scrollOffset: H, size: I } = c(O);
+        R.push({ index: O, offset: H, size: I });
+      }
+    return R;
+  }, [e, c, S, m]), te = l();
+  return q(
+    () => ({
+      items: Q,
+      measureElement: L,
+      scrollToIndex: _,
+      totalSize: te,
+      visibleRange: {
+        startIndex: w,
+        stopIndex: T
+      }
+    }),
+    [
+      Q,
+      L,
+      _,
+      w,
+      T,
+      te
+    ]
+  );
+}
+function ut(e, {
+  delay: t = 150
+} = {}) {
+  const [r, o] = C(!1);
+  return B(() => {
+    if (!e)
+      return;
+    const s = e === "window" ? window : Z(e), i = e === "window" ? s : e, n = "onscrollend" in s;
+    let d, v = 0;
+    const h = () => {
+      performance.now() - v >= t ? (d = void 0, o(!1)) : d = s.requestAnimationFrame(h);
+    }, f = () => {
+      o(!0), n || (v = performance.now(), d === void 0 && (d = s.requestAnimationFrame(h)));
+    }, u = () => {
+      o(!1);
+    };
+    return i.addEventListener("scroll", f, { passive: !0 }), n && i.addEventListener("scrollend", u), () => {
+      i.removeEventListener("scroll", f), i.removeEventListener("scrollend", u), d !== void 0 && s.cancelAnimationFrame(d), o(!1);
+    };
+  }, [t, e]), r;
 }
-const De = M, Xe = H, be = /* @__PURE__ */ new WeakMap();
-function Ze(e = !1, t = typeof document < "u" ? document : void 0) {
+const Te = /* @__PURE__ */ new WeakMap();
+function dt(e = !1, t = typeof document < "u" ? document : void 0) {
   if (t === void 0)
     return 0;
-  let s = be.get(t);
-  if (s === void 0 || e) {
-    const o = t.createElement("div"), r = o.style;
-    r.width = "50px", r.height = "50px", r.overflow = "scroll", t.body.appendChild(o), s = o.offsetWidth - o.clientWidth, t.body.removeChild(o), be.set(t, s);
+  let r = Te.get(t);
+  if (r === void 0 || e) {
+    const o = t.createElement("div"), s = o.style;
+    s.width = "50px", s.height = "50px", s.overflow = "scroll", t.body.appendChild(o), r = o.offsetWidth - o.clientWidth, t.body.removeChild(o), Te.set(t, r);
   }
-  return s;
+  return r;
 }
 export {
-  Ne as Grid,
-  _e as List,
-  Ze as getScrollbarSize,
-  Ye as useDynamicRowHeight,
-  qe as useGridCallbackRef,
-  Ge as useGridRef,
-  De as useListCallbackRef,
-  Xe as useListRef
+  rt as Grid,
+  it as List,
+  dt as getScrollbarSize,
+  lt as useDynamicRowHeight,
+  ot as useGridCallbackRef,
+  nt as useGridRef,
+  ut as useIsScrolling,
+  ct as useListCallbackRef,
+  at as useListRef,
+  ft as useVirtualizer
 };
 //# sourceMappingURL=react-window.js.map