@fluidattacks/design 8.0.0 → 8.2.0

package/dist/node_modules/@tanstack/virtual-core/dist/esm/index.js

@@ -0,0 +1,696 @@
+import { createLazyMeasurementsView as R } from "./lazy-measurements.js";
+import { memo as E, notUndefined as T, approxEqual as F, debounce as W } from "./utils.js";
+let _;
+const y = () => {
+  if (_ !== void 0) return _;
+  if (typeof navigator > "u") return _ = !1;
+  if (/iP(hone|od|ad)/.test(navigator.userAgent)) return _ = !0;
+  const l = navigator.maxTouchPoints;
+  return _ = navigator.platform === "MacIntel" && l !== void 0 && l > 0;
+}, C = (l) => {
+  const { offsetWidth: h, offsetHeight: e } = l;
+  return { width: h, height: e };
+}, k = (l) => l, D = (l) => {
+  const h = Math.max(l.startIndex - l.overscan, 0), s = Math.min(l.endIndex + l.overscan, l.count - 1) - h + 1, t = new Array(s);
+  for (let i = 0; i < s; i++)
+    t[i] = h + i;
+  return t;
+}, J = (l, h) => {
+  const e = l.scrollElement;
+  if (!e)
+    return;
+  const s = l.targetWindow;
+  if (!s)
+    return;
+  const t = (n) => {
+    const { width: o, height: r } = n;
+    h({ width: Math.round(o), height: Math.round(r) });
+  };
+  if (t(C(e)), !s.ResizeObserver)
+    return () => {
+    };
+  const i = new s.ResizeObserver((n) => {
+    const o = () => {
+      const r = n[0];
+      if (r?.borderBoxSize) {
+        const a = r.borderBoxSize[0];
+        if (a) {
+          t({ width: a.inlineSize, height: a.blockSize });
+          return;
+        }
+      }
+      t(C(e));
+    };
+    l.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(o) : o();
+  });
+  return i.observe(e, { box: "border-box" }), () => {
+    i.unobserve(e);
+  };
+}, z = {
+  passive: !0
+}, L = typeof window > "u" ? !0 : "onscrollend" in window, N = (l, h, e) => {
+  const s = l.scrollElement;
+  if (!s)
+    return;
+  const t = l.targetWindow;
+  if (!t)
+    return;
+  const i = l.options.useScrollendEvent && L;
+  let n = 0;
+  const o = i ? null : W(
+    t,
+    () => h(n, !1),
+    l.options.isScrollingResetDelay
+  ), r = (d) => () => {
+    n = e(s), o?.(), h(n, d);
+  }, a = r(!0), c = r(!1);
+  return s.addEventListener("scroll", a, z), i && s.addEventListener("scrollend", c, z), () => {
+    s.removeEventListener("scroll", a), i && s.removeEventListener("scrollend", c);
+  };
+}, K = (l, h) => N(l, h, (e) => {
+  const { horizontal: s, isRtl: t } = l.options;
+  return s ? e.scrollLeft * (t && -1 || 1) : e.scrollTop;
+}), V = (l, h, e) => {
+  if (h?.borderBoxSize) {
+    const s = h.borderBoxSize[0];
+    if (s)
+      return Math.round(
+        s[e.options.horizontal ? "inlineSize" : "blockSize"]
+      );
+  }
+  return l[e.options.horizontal ? "offsetWidth" : "offsetHeight"];
+}, j = (l, {
+  adjustments: h = 0,
+  behavior: e
+}, s) => {
+  var t, i;
+  (i = (t = s.scrollElement) == null ? void 0 : t.scrollTo) == null || i.call(t, {
+    [s.options.horizontal ? "left" : "top"]: l + h,
+    behavior: e
+  });
+}, q = j;
+class U {
+  constructor(h) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.scrollState = null, this.measurementsCache = [], this._flatMeasurements = null, this.itemSizeCache = /* @__PURE__ */ new Map(), this.itemSizeCacheVersion = 0, this.laneAssignments = /* @__PURE__ */ new Map(), this.pendingMin = null, this.prevLanes = void 0, this.lanesChangedFlag = !1, this.lanesSettling = !1, this.scrollRect = null, this.scrollOffset = null, this.scrollDirection = null, this.scrollAdjustments = 0, this._iosDeferredAdjustment = 0, this._iosTouching = !1, this._iosJustTouchEnded = !1, this._iosTouchEndTimerId = null, this._intendedScrollOffset = null, this.elementsCache = /* @__PURE__ */ new Map(), this.now = () => {
+      var e, s, t;
+      return ((t = (s = (e = this.targetWindow) == null ? void 0 : e.performance) == null ? void 0 : s.now) == null ? void 0 : t.call(s)) ?? Date.now();
+    }, this.observer = /* @__PURE__ */ (() => {
+      let e = null;
+      const s = () => e || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : e = new this.targetWindow.ResizeObserver((t) => {
+        t.forEach((i) => {
+          const n = () => {
+            const o = i.target, r = this.indexFromElement(o);
+            if (!o.isConnected) {
+              this.observer.unobserve(o);
+              for (const [a, c] of this.elementsCache)
+                if (c === o) {
+                  this.elementsCache.delete(a);
+                  break;
+                }
+              return;
+            }
+            this.shouldMeasureDuringScroll(r) && this.resizeItem(
+              r,
+              this.options.measureElement(o, i, this)
+            );
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(n) : n();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var t;
+          (t = s()) == null || t.disconnect(), e = null;
+        },
+        observe: (t) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.observe(t, { box: "border-box" });
+        },
+        unobserve: (t) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.unobserve(t);
+        }
+      };
+    })(), this.range = null, this.setOptions = (e) => {
+      const s = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: k,
+        rangeExtractor: D,
+        onChange: () => {
+        },
+        measureElement: V,
+        initialRect: { width: 0, height: 0 },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        isScrollingResetDelay: 150,
+        enabled: !0,
+        isRtl: !1,
+        useScrollendEvent: !1,
+        useAnimationFrameWithResizeObserver: !1,
+        laneAssignmentMode: "estimate"
+      };
+      for (const t in e) {
+        const i = e[t];
+        i !== void 0 && (s[t] = i);
+      }
+      this.options = s;
+    }, this.notify = (e) => {
+      var s, t;
+      (t = (s = this.options).onChange) == null || t.call(s, this, e);
+    }, this.maybeNotify = E(
+      () => (this.calculateRange(), [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]),
+      (e) => {
+        this.notify(e);
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "maybeNotify",
+        debug: () => this.options.debug,
+        initialDeps: [
+          this.isScrolling,
+          this.range ? this.range.startIndex : null,
+          this.range ? this.range.endIndex : null
+        ]
+      }
+    ), this.cleanup = () => {
+      this.unsubs.filter(Boolean).forEach((e) => e()), this.unsubs = [], this.observer.disconnect(), this.rafId != null && this.targetWindow && (this.targetWindow.cancelAnimationFrame(this.rafId), this.rafId = null), this.scrollState = null, this.scrollElement = null, this.targetWindow = null;
+    }, this._didMount = () => () => {
+      this.cleanup();
+    }, this._willUpdate = () => {
+      var e;
+      const s = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== s) {
+        if (this.cleanup(), !s) {
+          this.maybeNotify();
+          return;
+        }
+        if (this.scrollElement = s, this.scrollElement && "ownerDocument" in this.scrollElement ? this.targetWindow = this.scrollElement.ownerDocument.defaultView : this.targetWindow = ((e = this.scrollElement) == null ? void 0 : e.window) ?? null, this.elementsCache.forEach((t) => {
+          this.observer.observe(t);
+        }), this.unsubs.push(
+          this.options.observeElementRect(this, (t) => {
+            this.scrollRect = t, this.maybeNotify();
+          })
+        ), this.unsubs.push(
+          this.options.observeElementOffset(this, (t, i) => {
+            this._intendedScrollOffset !== null && Math.abs(t - this._intendedScrollOffset) < 1.5 && (t = this._intendedScrollOffset), this._intendedScrollOffset = null, this.scrollAdjustments = 0, this.scrollDirection = i ? this.getScrollOffset() < t ? "forward" : "backward" : null, this.scrollOffset = t, this.isScrolling = i, this._flushIosDeferredIfReady(), this.scrollState && this.scheduleScrollReconcile(), this.maybeNotify();
+          })
+        ), "addEventListener" in this.scrollElement) {
+          const t = this.scrollElement, i = () => {
+            this._iosTouching = !0, this._iosJustTouchEnded = !1, this._iosTouchEndTimerId !== null && this.targetWindow != null && (this.targetWindow.clearTimeout(this._iosTouchEndTimerId), this._iosTouchEndTimerId = null);
+          }, n = () => {
+            this._iosTouching = !1, !(!y() || this.targetWindow == null) && (this._iosJustTouchEnded = !0, this._iosTouchEndTimerId = this.targetWindow.setTimeout(() => {
+              this._iosJustTouchEnded = !1, this._iosTouchEndTimerId = null, this._flushIosDeferredIfReady();
+            }, 150));
+          };
+          t.addEventListener(
+            "touchstart",
+            i,
+            z
+          ), t.addEventListener(
+            "touchend",
+            n,
+            z
+          ), this.unsubs.push(() => {
+            t.removeEventListener("touchstart", i), t.removeEventListener("touchend", n), this._iosTouchEndTimerId !== null && this.targetWindow != null && (this.targetWindow.clearTimeout(this._iosTouchEndTimerId), this._iosTouchEndTimerId = null);
+          });
+        }
+        this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        });
+      }
+    }, this._flushIosDeferredIfReady = () => {
+      if (this._iosDeferredAdjustment === 0 || this.isScrolling || this._iosTouching || this._iosJustTouchEnded) return;
+      const e = this.getScrollOffset(), s = this.getMaxScrollOffset();
+      if (e < 0 || e > s) return;
+      const t = this._iosDeferredAdjustment;
+      this._iosDeferredAdjustment = 0, this._scrollToOffset(e, {
+        adjustments: this.scrollAdjustments += t,
+        behavior: void 0
+      });
+    }, this.rafId = null, this.getSize = () => this.options.enabled ? (this.scrollRect = this.scrollRect ?? this.options.initialRect, this.scrollRect[this.options.horizontal ? "width" : "height"]) : (this.scrollRect = null, 0), this.getScrollOffset = () => this.options.enabled ? (this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset == "function" ? this.options.initialOffset() : this.options.initialOffset), this.scrollOffset) : (this.scrollOffset = null, 0), this.getFurthestMeasurement = (e, s) => {
+      const t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+      for (let n = s - 1; n >= 0; n--) {
+        const o = e[n];
+        if (t.has(o.lane))
+          continue;
+        const r = i.get(
+          o.lane
+        );
+        if (r == null || o.end > r.end ? i.set(o.lane, o) : o.end < r.end && t.set(o.lane, !0), t.size === this.options.lanes)
+          break;
+      }
+      return i.size === this.options.lanes ? Array.from(i.values()).sort((n, o) => n.end === o.end ? n.index - o.index : n.end - o.end)[0] : void 0;
+    }, this.getMeasurementOptions = E(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled,
+        this.options.lanes,
+        this.options.laneAssignmentMode
+      ],
+      (e, s, t, i, n, o, r) => (this.prevLanes !== void 0 && this.prevLanes !== o && (this.lanesChangedFlag = !0), this.prevLanes = o, this.pendingMin = null, {
+        count: e,
+        paddingStart: s,
+        scrollMargin: t,
+        getItemKey: i,
+        enabled: n,
+        lanes: o,
+        laneAssignmentMode: r
+      }),
+      {
+        key: !1
+      }
+    ), this.getMeasurements = E(
+      () => [this.getMeasurementOptions(), this.itemSizeCacheVersion],
+      ({
+        count: e,
+        paddingStart: s,
+        scrollMargin: t,
+        getItemKey: i,
+        enabled: n,
+        lanes: o,
+        laneAssignmentMode: r
+      }, a) => {
+        const c = this.itemSizeCache;
+        if (!n)
+          return this.measurementsCache = [], this.itemSizeCache.clear(), this.laneAssignments.clear(), [];
+        if (this.laneAssignments.size > e)
+          for (const u of this.laneAssignments.keys())
+            u >= e && this.laneAssignments.delete(u);
+        this.lanesChangedFlag && (this.lanesChangedFlag = !1, this.lanesSettling = !0, this.measurementsCache = [], this.itemSizeCache.clear(), this.laneAssignments.clear(), this.pendingMin = null), this.measurementsCache.length === 0 && !this.lanesSettling && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((u) => {
+          this.itemSizeCache.set(u.key, u.size);
+        }));
+        const d = this.lanesSettling ? 0 : this.pendingMin ?? 0;
+        if (this.pendingMin = null, this.lanesSettling && this.measurementsCache.length === e && (this.lanesSettling = !1), o === 1) {
+          const u = this.options.gap, S = e * 2;
+          let m = this._flatMeasurements;
+          if (!m || m.length < S) {
+            const g = new Float64Array(S);
+            m && d > 0 && g.set(m.subarray(0, d * 2)), m = g, this._flatMeasurements = m;
+          }
+          let p;
+          if (d === 0)
+            p = s + t;
+          else {
+            const g = d - 1;
+            p = m[g * 2] + m[g * 2 + 1] + u;
+          }
+          for (let g = d; g < e; g++) {
+            const M = i(g), O = c.get(M), I = typeof O == "number" ? O : this.options.estimateSize(g);
+            m[g * 2] = p, m[g * 2 + 1] = I, p += I + u;
+          }
+          const v = R(e, m, i);
+          return this.measurementsCache = v, v;
+        }
+        const f = this.measurementsCache.slice(0, d), x = new Array(o).fill(
+          void 0
+        );
+        for (let u = 0; u < d; u++) {
+          const S = f[u];
+          S && (x[S.lane] = u);
+        }
+        for (let u = d; u < e; u++) {
+          const S = i(u), m = this.laneAssignments.get(u);
+          let p, v;
+          const g = r === "estimate" || c.has(S);
+          if (m !== void 0 && this.options.lanes > 1) {
+            p = m;
+            const b = x[p], w = b !== void 0 ? f[b] : void 0;
+            v = w ? w.end + this.options.gap : s + t;
+          } else {
+            const b = this.options.lanes === 1 ? f[u - 1] : this.getFurthestMeasurement(f, u);
+            v = b ? b.end + this.options.gap : s + t, p = b ? b.lane : u % this.options.lanes, this.options.lanes > 1 && g && this.laneAssignments.set(u, p);
+          }
+          const M = c.get(S), O = typeof M == "number" ? M : this.options.estimateSize(u), I = v + O;
+          f[u] = {
+            index: u,
+            start: v,
+            size: O,
+            end: I,
+            key: S,
+            lane: p
+          }, x[p] = u;
+        }
+        return this.measurementsCache = f, f;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = E(
+      () => [
+        this.getMeasurements(),
+        this.getSize(),
+        this.getScrollOffset(),
+        this.options.lanes
+      ],
+      (e, s, t, i) => this.range = e.length > 0 && s > 0 ? P({
+        measurements: e,
+        outerSize: s,
+        scrollOffset: t,
+        lanes: i,
+        // Pass the typed array so binary search + forward-walk can
+        // read start/end directly from Float64Array, skipping the
+        // Proxy traps that materialize a full VirtualItem per probe.
+        flat: i === 1 && this._flatMeasurements != null ? this._flatMeasurements : null
+      }) : null,
+      {
+        key: process.env.NODE_ENV !== "production" && "calculateRange",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualIndexes = E(
+      () => {
+        let e = null, s = null;
+        const t = this.calculateRange();
+        return t && (e = t.startIndex, s = t.endIndex), this.maybeNotify.updateDeps([this.isScrolling, e, s]), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          e,
+          s
+        ];
+      },
+      (e, s, t, i, n) => i === null || n === null ? [] : e({
+        startIndex: i,
+        endIndex: n,
+        overscan: s,
+        count: t
+      }),
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+        debug: () => this.options.debug
+      }
+    ), this.indexFromElement = (e) => {
+      const s = this.options.indexAttribute, t = e.getAttribute(s);
+      return t ? parseInt(t, 10) : (console.warn(
+        `Missing attribute name '${s}={index}' on measured element.`
+      ), -1);
+    }, this.shouldMeasureDuringScroll = (e) => {
+      var s;
+      if (!this.scrollState || this.scrollState.behavior !== "smooth")
+        return !0;
+      const t = this.scrollState.index ?? ((s = this.getVirtualItemForOffset(this.scrollState.lastTargetOffset)) == null ? void 0 : s.index);
+      if (t !== void 0 && this.range) {
+        const i = Math.max(
+          this.options.overscan,
+          Math.ceil((this.range.endIndex - this.range.startIndex) / 2)
+        ), n = Math.max(0, t - i), o = Math.min(
+          this.options.count - 1,
+          t + i
+        );
+        return e >= n && e <= o;
+      }
+      return !0;
+    }, this.measureElement = (e) => {
+      if (!e) {
+        this.elementsCache.forEach((n, o) => {
+          n.isConnected || (this.observer.unobserve(n), this.elementsCache.delete(o));
+        });
+        return;
+      }
+      const s = this.indexFromElement(e), t = this.options.getItemKey(s), i = this.elementsCache.get(t);
+      i !== e && (i && this.observer.unobserve(i), this.observer.observe(e), this.elementsCache.set(t, e)), (!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(s) && this.resizeItem(s, this.options.measureElement(e, void 0, this));
+    }, this.resizeItem = (e, s) => {
+      var t;
+      if (e < 0 || e >= this.options.count) return;
+      let i, n, o;
+      const r = this._flatMeasurements;
+      if (this.options.lanes === 1 && r !== null)
+        o = this.options.getItemKey(e), n = r[e * 2], i = r[e * 2 + 1];
+      else {
+        const d = this.measurementsCache[e];
+        if (!d) return;
+        o = d.key, n = d.start, i = d.size;
+      }
+      const a = this.itemSizeCache.get(o) ?? i, c = s - a;
+      c !== 0 && (((t = this.scrollState) == null ? void 0 : t.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(
+        // The callback expects a VirtualItem; build one lazily only
+        // when the consumer actually supplied a custom predicate.
+        this.measurementsCache[e] ?? {
+          index: e,
+          key: o,
+          start: n,
+          size: i,
+          end: n + i,
+          lane: 0
+        },
+        c,
+        this
+      ) : (
+        // Default: adjust scrollTop only when the resize is an above-
+        // viewport item AND we're not actively scrolling backward.
+        // Adjusting during backward scroll fights the user's scroll
+        // direction and produces the "items jump while scrolling up"
+        // jank reported across many issues. Users who want the old
+        // behavior can pass shouldAdjustScrollPositionOnItemSizeChange.
+        n < this.getScrollOffset() + this.scrollAdjustments && this.scrollDirection !== "backward"
+      )) && (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", c), y() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded) ? this._iosDeferredAdjustment += c : this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += c,
+        behavior: void 0
+      })), (this.pendingMin === null || e < this.pendingMin) && (this.pendingMin = e), this.itemSizeCache.set(o, s), this.itemSizeCacheVersion++, this.notify(!1));
+    }, this.getVirtualItems = E(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (e, s) => {
+        const t = [];
+        for (let i = 0, n = e.length; i < n; i++) {
+          const o = e[i], r = s[o];
+          t.push(r);
+        }
+        return t;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualItemForOffset = (e) => {
+      const s = this.getMeasurements();
+      if (s.length === 0)
+        return;
+      const t = this._flatMeasurements, i = this.options.lanes === 1 && t != null, n = A(
+        0,
+        s.length - 1,
+        i ? (o) => t[o * 2] : (o) => T(s[o]).start,
+        e
+      );
+      return T(s[n]);
+    }, this.getMaxScrollOffset = () => {
+      if (!this.scrollElement) return 0;
+      if ("scrollHeight" in this.scrollElement)
+        return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+      {
+        const e = this.scrollElement.document.documentElement;
+        return this.options.horizontal ? e.scrollWidth - this.scrollElement.innerWidth : e.scrollHeight - this.scrollElement.innerHeight;
+      }
+    }, this.getOffsetForAlignment = (e, s, t = 0) => {
+      if (!this.scrollElement) return 0;
+      const i = this.getSize(), n = this.getScrollOffset();
+      s === "auto" && (s = e >= n + i ? "end" : "start"), s === "center" ? e += (t - i) / 2 : s === "end" && (e -= i);
+      const o = this.getMaxScrollOffset();
+      return Math.max(Math.min(o, e), 0);
+    }, this.getOffsetForIndex = (e, s = "auto") => {
+      e = Math.max(0, Math.min(e, this.options.count - 1));
+      const t = this.getSize(), i = this.getScrollOffset(), n = this.measurementsCache[e];
+      if (!n) return;
+      if (s === "auto")
+        if (n.end >= i + t - this.options.scrollPaddingEnd)
+          s = "end";
+        else if (n.start <= i + this.options.scrollPaddingStart)
+          s = "start";
+        else
+          return [i, s];
+      if (s === "end" && e === this.options.count - 1)
+        return [this.getMaxScrollOffset(), s];
+      const o = s === "end" ? n.end + this.options.scrollPaddingEnd : n.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(o, s, n.size),
+        s
+      ];
+    }, this.scrollToOffset = (e, { align: s = "start", behavior: t = "auto" } = {}) => {
+      const i = this.getOffsetForAlignment(e, s), n = this.now();
+      this.scrollState = {
+        index: null,
+        align: s,
+        behavior: t,
+        startedAt: n,
+        lastTargetOffset: i,
+        stableFrames: 0
+      }, this._scrollToOffset(i, { adjustments: void 0, behavior: t }), this.scheduleScrollReconcile();
+    }, this.scrollToIndex = (e, {
+      align: s = "auto",
+      behavior: t = "auto"
+    } = {}) => {
+      e = Math.max(0, Math.min(e, this.options.count - 1));
+      const i = this.getOffsetForIndex(e, s);
+      if (!i)
+        return;
+      const [n, o] = i, r = this.now();
+      this.scrollState = {
+        index: e,
+        align: o,
+        behavior: t,
+        startedAt: r,
+        lastTargetOffset: n,
+        stableFrames: 0
+      }, this._scrollToOffset(n, { adjustments: void 0, behavior: t }), this.scheduleScrollReconcile();
+    }, this.scrollBy = (e, { behavior: s = "auto" } = {}) => {
+      const t = this.getScrollOffset() + e, i = this.now();
+      this.scrollState = {
+        index: null,
+        align: "start",
+        behavior: s,
+        startedAt: i,
+        lastTargetOffset: t,
+        stableFrames: 0
+      }, this._scrollToOffset(t, { adjustments: void 0, behavior: s }), this.scheduleScrollReconcile();
+    }, this.getTotalSize = () => {
+      var e;
+      const s = this.getMeasurements();
+      let t;
+      if (s.length === 0)
+        t = this.options.paddingStart;
+      else if (this.options.lanes === 1) {
+        const i = s.length - 1, n = this._flatMeasurements;
+        n != null ? t = n[i * 2] + n[i * 2 + 1] : t = ((e = s[i]) == null ? void 0 : e.end) ?? 0;
+      } else {
+        const i = Array(this.options.lanes).fill(null);
+        let n = s.length - 1;
+        for (; n >= 0 && i.some((o) => o === null); ) {
+          const o = s[n];
+          i[o.lane] === null && (i[o.lane] = o.end), n--;
+        }
+        t = Math.max(...i.filter((o) => o !== null));
+      }
+      return Math.max(
+        t - this.options.scrollMargin + this.options.paddingEnd,
+        0
+      );
+    }, this.takeSnapshot = () => {
+      const e = [];
+      if (this.itemSizeCache.size === 0) return e;
+      const s = this.getMeasurements();
+      for (const t of s)
+        t && this.itemSizeCache.has(t.key) && e.push({
+          index: t.index,
+          key: t.key,
+          start: t.start,
+          size: t.size,
+          end: t.end,
+          lane: t.lane
+        });
+      return e;
+    }, this._scrollToOffset = (e, {
+      adjustments: s,
+      behavior: t
+    }) => {
+      this._intendedScrollOffset = e + (s ?? 0), this.options.scrollToFn(e, { behavior: t, adjustments: s }, this);
+    }, this.measure = () => {
+      this.pendingMin = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), this.itemSizeCacheVersion++, this.notify(!1);
+    }, this.setOptions(h);
+  }
+  scheduleScrollReconcile() {
+    if (!this.targetWindow) {
+      this.scrollState = null;
+      return;
+    }
+    this.rafId == null && (this.rafId = this.targetWindow.requestAnimationFrame(() => {
+      this.rafId = null, this.reconcileScroll();
+    }));
+  }
+  reconcileScroll() {
+    if (!this.scrollState || !this.scrollElement) return;
+    if (this.now() - this.scrollState.startedAt > 5e3) {
+      this.scrollState = null;
+      return;
+    }
+    const s = this.scrollState.index != null ? this.getOffsetForIndex(this.scrollState.index, this.scrollState.align) : void 0, t = s ? s[0] : this.scrollState.lastTargetOffset, i = 1, n = t !== this.scrollState.lastTargetOffset;
+    if (!n && F(t, this.getScrollOffset())) {
+      if (this.scrollState.stableFrames++, this.scrollState.stableFrames >= i) {
+        this.getScrollOffset() !== t && this._scrollToOffset(t, {
+          adjustments: void 0,
+          behavior: "auto"
+        }), this.scrollState = null;
+        return;
+      }
+    } else if (this.scrollState.stableFrames = 0, n) {
+      const o = this.getSize() || 600, r = Math.abs(t - this.getScrollOffset()), a = this.scrollState.behavior === "smooth" && r > o;
+      this.scrollState.lastTargetOffset = t, a || (this.scrollState.behavior = "auto"), this._scrollToOffset(t, {
+        adjustments: void 0,
+        behavior: a ? "smooth" : "auto"
+      });
+    }
+    this.scheduleScrollReconcile();
+  }
+}
+const A = (l, h, e, s) => {
+  for (; l <= h; ) {
+    const t = (l + h) / 2 | 0, i = e(t);
+    if (i < s)
+      l = t + 1;
+    else if (i > s)
+      h = t - 1;
+    else
+      return t;
+  }
+  return l > 0 ? l - 1 : 0;
+};
+function P({
+  measurements: l,
+  outerSize: h,
+  scrollOffset: e,
+  lanes: s,
+  flat: t
+}) {
+  const i = l.length - 1, n = t ? (c) => t[c * 2] : (c) => l[c].start, o = t ? (c) => t[c * 2] + t[c * 2 + 1] : (c) => l[c].end;
+  if (l.length <= s)
+    return {
+      startIndex: 0,
+      endIndex: i
+    };
+  let r = A(0, i, n, e), a = r;
+  if (s === 1)
+    for (; a < i && o(a) < e + h; )
+      a++;
+  else if (s > 1) {
+    const c = Array(s).fill(0);
+    for (; a < i && c.some((f) => f < e + h); ) {
+      const f = l[a];
+      c[f.lane] = f.end, a++;
+    }
+    const d = Array(s).fill(e + h);
+    for (; r >= 0 && d.some((f) => f >= e); ) {
+      const f = l[r];
+      d[f.lane] = f.start, r--;
+    }
+    r = Math.max(0, r - r % s), a = Math.min(i, a + (s - 1 - a % s));
+  }
+  return { startIndex: r, endIndex: a };
+}
+export {
+  U as Virtualizer,
+  F as approxEqual,
+  W as debounce,
+  k as defaultKeyExtractor,
+  D as defaultRangeExtractor,
+  q as elementScroll,
+  V as measureElement,
+  E as memo,
+  T as notUndefined,
+  K as observeElementOffset,
+  J as observeElementRect
+};