react-window 2.4.1 → 2.5.0

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