@synopackageland/ui 0.25.20 → 0.25.22

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

@@ -0,0 +1,852 @@
+import { createLazyMeasurementsView as N, getMeasurementKey as K } from "./lazy-measurements.js";
+import { memo as M, approxEqual as L, notUndefined as W, debounce as P } from "./utils.js";
+let C;
+const F = () => {
+  if (C !== void 0) return C;
+  if (typeof navigator > "u") return C = !1;
+  if (/iP(hone|od|ad)/.test(navigator.userAgent)) return C = !0;
+  const r = navigator.maxTouchPoints;
+  return C = navigator.platform === "MacIntel" && r !== void 0 && r > 0;
+}, k = (r) => {
+  const { offsetWidth: h, offsetHeight: t } = r;
+  return { width: h, height: t };
+}, B = (r) => r, H = (r) => {
+  const h = Math.max(r.startIndex - r.overscan, 0), s = Math.min(r.endIndex + r.overscan, r.count - 1) - h + 1, e = new Array(s);
+  for (let i = 0; i < s; i++)
+    e[i] = h + i;
+  return e;
+}, tt = (r, h) => {
+  const t = r.scrollElement;
+  if (!t)
+    return;
+  const s = r.targetWindow;
+  if (!s)
+    return;
+  const e = (n) => {
+    const { width: l, height: o } = n;
+    h({ width: Math.round(l), height: Math.round(o) });
+  };
+  if (e(k(t)), !s.ResizeObserver)
+    return () => {
+    };
+  const i = new s.ResizeObserver((n) => {
+    const l = () => {
+      const o = n[0];
+      if (o?.borderBoxSize) {
+        const a = o.borderBoxSize[0];
+        if (a) {
+          e({ width: a.inlineSize, height: a.blockSize });
+          return;
+        }
+      }
+      e(k(t));
+    };
+    r.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(l) : l();
+  });
+  return i.observe(t, { box: "border-box" }), () => {
+    i.unobserve(t);
+  };
+}, j = {
+  passive: !0
+}, J = typeof window > "u" ? !0 : "onscrollend" in window, q = (r, h, t) => {
+  const s = r.scrollElement;
+  if (!s)
+    return;
+  const e = r.targetWindow;
+  if (!e)
+    return;
+  const i = r.options.useScrollendEvent && J;
+  let n = 0;
+  const l = i ? null : P(
+    e,
+    () => h(t(s), !1),
+    r.options.isScrollingResetDelay
+  ), o = (c) => () => {
+    n = t(s), l?.(), h(n, c);
+  }, a = o(!0), f = o(!1);
+  return s.addEventListener("scroll", a, j), i && s.addEventListener("scrollend", f, j), () => {
+    s.removeEventListener("scroll", a), i && s.removeEventListener("scrollend", f), l?.cancel();
+  };
+}, et = (r, h) => q(r, h, (t) => {
+  const { horizontal: s, isRtl: e } = r.options;
+  return s ? t.scrollLeft * (e && -1 || 1) : t.scrollTop;
+}), U = (r, h, t) => {
+  if (t.options.useCachedMeasurements) {
+    const s = t.indexFromElement(r), e = t.options.getItemKey(s);
+    return t.itemSizeCache.get(e) ?? t.options.estimateSize(s);
+  }
+  if (h?.borderBoxSize) {
+    const s = h.borderBoxSize[0];
+    if (s)
+      return Math.round(
+        s[t.options.horizontal ? "inlineSize" : "blockSize"]
+      );
+  }
+  if (!h) {
+    const s = t.indexFromElement(r), e = t.options.getItemKey(s), i = t.itemSizeCache.get(e);
+    if (i !== void 0)
+      return i;
+  }
+  return r[t.options.horizontal ? "offsetWidth" : "offsetHeight"];
+}, X = (r, {
+  adjustments: h = 0,
+  behavior: t
+}, s) => {
+  var e, i;
+  (i = (e = s.scrollElement) == null ? void 0 : e.scrollTo) == null || i.call(e, {
+    [s.options.horizontal ? "left" : "top"]: r + h,
+    behavior: t
+  });
+}, st = X;
+function $(r, h, t, s) {
+  if (h === 0) return !1;
+  const e = s(0), i = /* @__PURE__ */ new Set();
+  let n = 0;
+  for (; n < r; ) {
+    const o = t(n);
+    if (o === e) break;
+    i.add(o), n++;
+  }
+  const l = r - n;
+  if (l === 0 || l >= h) return !1;
+  for (let o = 0; o < l; o++)
+    if (s(o) !== t(n + o)) return !1;
+  for (let o = l; o < h; o++)
+    if (i.has(s(o))) return !1;
+  return !0;
+}
+class it {
+  constructor(h) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.scrollState = null, this.measurementsCache = [], this._singleLaneMeasurements = 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.pendingScrollAnchor = null, 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._clampedAdjustment = null, this.elementsCache = /* @__PURE__ */ new Map(), this.now = () => {
+      var t, s, e;
+      return ((e = (s = (t = this.targetWindow) == null ? void 0 : t.performance) == null ? void 0 : s.now) == null ? void 0 : e.call(s)) ?? Date.now();
+    }, this.observer = /* @__PURE__ */ (() => {
+      let t = null;
+      const s = () => t || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : t = new this.targetWindow.ResizeObserver((e) => {
+        e.forEach((i) => {
+          const n = () => {
+            const l = i.target, o = this.indexFromElement(l);
+            if (!l.isConnected) {
+              this.observer.unobserve(l);
+              for (const [a, f] of this.elementsCache)
+                if (f === l) {
+                  this.elementsCache.delete(a);
+                  break;
+                }
+              return;
+            }
+            this.isIndexInRange(o) && this.shouldMeasureDuringScroll(o) && this.resizeItem(
+              o,
+              this.options.measureElement(l, i, this)
+            );
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(n) : n();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var e;
+          (e = s()) == null || e.disconnect(), t = null;
+        },
+        observe: (e) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.observe(e, { box: "border-box" });
+        },
+        unobserve: (e) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.unobserve(e);
+        }
+      };
+    })(), this.range = null, this.setOptions = (t) => {
+      var s;
+      const e = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: B,
+        rangeExtractor: H,
+        onChange: () => {
+        },
+        measureElement: U,
+        initialRect: { width: 0, height: 0 },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        anchorTo: "start",
+        followOnAppend: !1,
+        scrollEndThreshold: 1,
+        isScrollingResetDelay: 150,
+        enabled: !0,
+        isRtl: !1,
+        useScrollendEvent: !1,
+        useAnimationFrameWithResizeObserver: !1,
+        laneAssignmentMode: "estimate",
+        useCachedMeasurements: !1
+      };
+      for (const c in t) {
+        const g = t[c];
+        g !== void 0 && (e[c] = g);
+      }
+      const i = this.options;
+      let n = null, l = null, o = !1;
+      if (i !== void 0 && i.enabled && e.enabled && e.anchorTo === "end" && this.scrollElement !== null) {
+        const c = i.count, g = e.count, m = this.getMeasurements(), b = ((s = this._singleLaneMeasurements) == null ? void 0 : s.items) ?? m, S = (_) => K(b[_]), E = c > 0 ? S(0) : null, O = c > 0 ? S(c - 1) : null;
+        if (g !== c || c > 0 && g > 0 && (e.getItemKey(0) !== E || e.getItemKey(g - 1) !== O)) {
+          o = !0;
+          const _ = c > 0 ? this.getVirtualItemForOffset(this.getScrollOffset()) ?? m[0] : null;
+          _ && (n = [_.key, this.getScrollOffset() - _.start]);
+          const p = e.followOnAppend === !0 ? "auto" : e.followOnAppend || null;
+          p && g > 0 && this.isAtEnd(i.scrollEndThreshold) && (c === 0 || e.getItemKey(g - 1) !== O) && (g > c || $(
+            c,
+            g,
+            S,
+            e.getItemKey
+          )) && (l = p);
+        }
+      }
+      this.options = e, o && (this.pendingMin = 0, this.itemSizeCacheVersion++);
+      let a = !1, f = 0;
+      if (n && this.scrollOffset !== null) {
+        const [c, g] = n, m = this.getMeasurements(), { count: b, getItemKey: S } = this.options;
+        let E = 0;
+        for (; E < b && S(E) !== c; )
+          E++;
+        if (E < b) {
+          const O = m[E];
+          if (O) {
+            const u = Math.max(0, O.start + g);
+            !l && u !== this.scrollOffset && (f = u - this.scrollOffset, this.scrollOffset = u, a = !0);
+          }
+        }
+      }
+      (a || l) && (this.pendingScrollAnchor = [
+        a ? n[0] : null,
+        a ? n[1] : 0,
+        l,
+        f
+      ]);
+    }, this.notify = (t) => {
+      var s, e;
+      (e = (s = this.options).onChange) == null || e.call(s, this, t);
+    }, this.maybeNotify = M(
+      () => (this.calculateRange(), [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]),
+      (t) => {
+        this.notify(t);
+      },
+      {
+        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((t) => t()), this.unsubs = [], this.observer.disconnect(), this.rafId != null && this.targetWindow && (this.targetWindow.cancelAnimationFrame(this.rafId), this.rafId = null), this.scrollState = null, this.isScrolling = !1, this.scrollDirection = null, this._iosDeferredAdjustment = 0, this._iosTouching = !1, this._iosJustTouchEnded = !1, this._clampedAdjustment = null, this.scrollElement = null, this.targetWindow = null;
+    }, this._didMount = () => () => {
+      this.cleanup();
+    }, this._willUpdate = () => {
+      var t, s;
+      const e = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== e) {
+        if (this.cleanup(), !e) {
+          this.maybeNotify();
+          return;
+        }
+        if (this.scrollElement = e, this.scrollElement && "ownerDocument" in this.scrollElement ? this.targetWindow = this.scrollElement.ownerDocument.defaultView : this.targetWindow = ((t = this.scrollElement) == null ? void 0 : t.window) ?? null, this.elementsCache.forEach((n) => {
+          this.observer.observe(n);
+        }), this.unsubs.push(
+          this.options.observeElementRect(this, (n) => {
+            this.scrollRect = n, this.maybeNotify();
+          })
+        ), this.unsubs.push(
+          this.options.observeElementOffset(this, (n, l) => {
+            if (l && this._intendedScrollOffset === null && n === this.scrollOffset)
+              return;
+            this._intendedScrollOffset !== null && Math.abs(n - this._intendedScrollOffset) < 1.5 && (n = this._intendedScrollOffset), this._intendedScrollOffset = null, this._clampedAdjustment !== null && Math.abs(n - this._clampedAdjustment.maxAtWrite) >= 1.5 && (this._clampedAdjustment = null), this.scrollAdjustments = 0;
+            const o = this.getScrollOffset();
+            this.scrollDirection = l ? o === n ? this.scrollDirection : o < n ? "forward" : "backward" : null, this.scrollOffset = n, this.isScrolling = l, this._flushIosDeferredIfReady(), this.scrollState && this.scheduleScrollReconcile(), this.maybeNotify();
+          })
+        ), "addEventListener" in this.scrollElement) {
+          const n = this.scrollElement, l = () => {
+            this._iosTouching = !0, this._iosJustTouchEnded = !1, this._iosTouchEndTimerId !== null && this.targetWindow != null && (this.targetWindow.clearTimeout(this._iosTouchEndTimerId), this._iosTouchEndTimerId = null);
+          }, o = () => {
+            this._iosTouching = !1, !(!F() || this.targetWindow == null) && (this._iosJustTouchEnded = !0, this._iosTouchEndTimerId = this.targetWindow.setTimeout(() => {
+              this._iosJustTouchEnded = !1, this._iosTouchEndTimerId = null, this._flushIosDeferredIfReady();
+            }, 150));
+          };
+          n.addEventListener(
+            "touchstart",
+            l,
+            j
+          ), n.addEventListener(
+            "touchend",
+            o,
+            j
+          ), this.unsubs.push(() => {
+            n.removeEventListener("touchstart", l), n.removeEventListener("touchend", o), this._iosTouchEndTimerId !== null && this.targetWindow != null && (this.targetWindow.clearTimeout(this._iosTouchEndTimerId), this._iosTouchEndTimerId = null);
+          });
+        }
+        this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        });
+      }
+      const i = this.pendingScrollAnchor;
+      if (this.pendingScrollAnchor = null, i && this.scrollElement && this.options.enabled) {
+        const [n, l, o, a] = i;
+        n !== null && !o && (F() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded) ? a !== 0 && (this._iosDeferredAdjustment += a) : ((s = this.scrollState) == null ? void 0 : s.behavior) === "smooth" && !L(
+          this.getScrollOffset() - a,
+          this.scrollState.lastTargetOffset
+        ) || this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        })), o && this.scrollToEnd({ behavior: o });
+      }
+      this._retryClampedAdjustment();
+    }, this._retryClampedAdjustment = () => {
+      if (this._clampedAdjustment === null || !this.scrollElement || !this.options.enabled)
+        return;
+      const { target: t, maxAtWrite: s } = this._clampedAdjustment, e = this.getMaxScrollOffset();
+      e > s + 0.5 && (this._clampedAdjustment = t > e + 0.5 ? { target: t, maxAtWrite: e } : null, this._scrollToOffset(t, {
+        adjustments: void 0,
+        behavior: void 0
+      }));
+    }, this._flushIosDeferredIfReady = () => {
+      if (this._iosDeferredAdjustment === 0 || this.isScrolling || this._iosTouching || this._iosJustTouchEnded) return;
+      const t = this.getScrollOffset(), s = this.getMaxScrollOffset();
+      if (t < 0 || t > s) return;
+      if (this._iosDeferredAdjustment < 0 && t >= s - 1) {
+        this._iosDeferredAdjustment = 0;
+        return;
+      }
+      const e = this._iosDeferredAdjustment;
+      this._iosDeferredAdjustment = 0, this._scrollToOffset(t, {
+        adjustments: this.scrollAdjustments += e,
+        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.getMeasurementOptions = M(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled,
+        this.options.lanes,
+        this.options.laneAssignmentMode,
+        this.options.gap
+      ],
+      (t, s, e, i, n, l, o, a) => (this.prevLanes !== void 0 && this.prevLanes !== l && (this.lanesChangedFlag = !0), this.prevLanes = l, this.pendingMin = null, {
+        count: t,
+        paddingStart: s,
+        scrollMargin: e,
+        getItemKey: i,
+        enabled: n,
+        lanes: l,
+        laneAssignmentMode: o,
+        gap: a
+      }),
+      {
+        key: !1
+      }
+    ), this.isIndexInRange = (t) => t >= 0 && t < this.options.count, this.getMeasurements = M(
+      () => [this.getMeasurementOptions(), this.itemSizeCacheVersion],
+      ({
+        count: t,
+        paddingStart: s,
+        scrollMargin: e,
+        getItemKey: i,
+        enabled: n,
+        lanes: l,
+        laneAssignmentMode: o,
+        gap: a
+      }, f) => {
+        var c;
+        const g = this.itemSizeCache;
+        if (!n)
+          return this.measurementsCache = [], this._singleLaneMeasurements = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), [];
+        if (this.laneAssignments.size > t)
+          for (const u of this.laneAssignments.keys())
+            u >= t && this.laneAssignments.delete(u);
+        this.lanesChangedFlag && (this.lanesChangedFlag = !1, this.lanesSettling = !0, this.measurementsCache = [], this._singleLaneMeasurements = null, 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 m = this.lanesSettling ? 0 : this.pendingMin ?? 0;
+        if (this.pendingMin = null, this.lanesSettling && this.measurementsCache.length === t && (this.lanesSettling = !1), l === 1) {
+          const u = t * 2;
+          let d = (c = this._singleLaneMeasurements) == null ? void 0 : c.flat;
+          if (!d || d.length < u) {
+            const v = new Float64Array(u);
+            d && m > 0 && v.set(d.subarray(0, m * 2)), d = v;
+          }
+          const _ = m === 0 ? new Array(t) : this._singleLaneMeasurements.items.slice();
+          let p;
+          if (m === 0)
+            p = s + e;
+          else {
+            const v = m - 1;
+            p = d[v * 2] + d[v * 2 + 1] + a;
+          }
+          for (let v = m; v < t; v++) {
+            const y = i(v);
+            _[v] = y;
+            const T = g.get(y), z = typeof T == "number" ? T : this.options.estimateSize(v);
+            d[v * 2] = p, d[v * 2 + 1] = z, p += z + a;
+          }
+          this._singleLaneMeasurements = { flat: d, items: _ };
+          const A = N(_, d);
+          return this.measurementsCache = A, A;
+        }
+        const b = this.measurementsCache.slice(0, m), S = new Array(l).fill(
+          void 0
+        ), E = new Float64Array(l);
+        let O = 0;
+        for (let u = 0; u < m; u++) {
+          const d = b[u];
+          d && (S[d.lane] === void 0 && O++, S[d.lane] = u, E[d.lane] = d.end);
+        }
+        for (let u = m; u < t; u++) {
+          const d = i(u), _ = this.laneAssignments.get(u);
+          let p, A;
+          const v = o === "estimate" || g.has(d);
+          if (_ !== void 0 && this.options.lanes > 1) {
+            p = _;
+            const w = S[p], I = w !== void 0 ? b[w] : void 0;
+            A = I ? I.end + a : s + e;
+          } else if (O === l) {
+            let w = 0, I = E[0], D = S[0];
+            for (let x = 1; x < l; x++) {
+              const R = E[x];
+              (R < I || R === I && S[x] < D) && (w = x, I = R, D = S[x]);
+            }
+            p = w, A = I + a, v && this.laneAssignments.set(u, p);
+          } else
+            p = u % this.options.lanes, A = s + e, v && this.laneAssignments.set(u, p);
+          const y = g.get(d), T = typeof y == "number" ? y : this.options.estimateSize(u), z = A + T;
+          b[u] = {
+            index: u,
+            start: A,
+            size: T,
+            end: z,
+            key: d,
+            lane: p
+          }, S[p] === void 0 && O++, S[p] = u, E[p] = z;
+        }
+        return this.measurementsCache = b, b;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = M(
+      () => [
+        this.getMeasurements(),
+        this.getSize(),
+        this.getScrollOffset(),
+        this.options.lanes
+      ],
+      (t, s, e, i) => t.length === 0 || s === 0 ? (this.range = null, null) : (this.range = Q(
+        t,
+        s,
+        e,
+        i,
+        // Pass the typed array so binary search + forward-walk can read
+        // start/end directly from Float64Array, skipping the Proxy traps.
+        i === 1 && this._singleLaneMeasurements !== null ? this._singleLaneMeasurements.flat : null
+      ), this.range),
+      {
+        key: process.env.NODE_ENV !== "production" && "calculateRange",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualIndexes = M(
+      () => {
+        let t = null, s = null;
+        const e = this.calculateRange();
+        return e && (t = e.startIndex, s = e.endIndex), this.maybeNotify.updateDeps([this.isScrolling, t, s]), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          t,
+          s
+        ];
+      },
+      (t, s, e, i, n) => i === null || n === null ? [] : t({
+        startIndex: i,
+        endIndex: n,
+        overscan: s,
+        count: e
+      }),
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+        debug: () => this.options.debug
+      }
+    ), this.indexFromElement = (t) => {
+      const s = this.options.indexAttribute, e = t.getAttribute(s);
+      return e ? parseInt(e, 10) : (console.warn(
+        `Missing attribute name '${s}={index}' on measured element.`
+      ), -1);
+    }, this.shouldMeasureDuringScroll = (t) => {
+      var s;
+      if (!this.scrollState || this.scrollState.behavior !== "smooth")
+        return !0;
+      const e = this.scrollState.index ?? ((s = this.getVirtualItemForOffset(this.scrollState.lastTargetOffset)) == null ? void 0 : s.index);
+      if (e !== void 0 && this.range) {
+        const i = Math.max(
+          this.options.overscan,
+          Math.ceil((this.range.endIndex - this.range.startIndex) / 2)
+        ), n = Math.max(0, e - i), l = Math.min(
+          this.options.count - 1,
+          e + i
+        );
+        return t >= n && t <= l;
+      }
+      return !0;
+    }, this.measureElement = (t) => {
+      if (!t) {
+        this.elementsCache.forEach((n, l) => {
+          n.isConnected || (this.observer.unobserve(n), this.elementsCache.delete(l));
+        });
+        return;
+      }
+      const s = this.indexFromElement(t);
+      if (!this.isIndexInRange(s)) return;
+      const e = this.options.getItemKey(s), i = this.elementsCache.get(e);
+      i !== t && (i && this.observer.unobserve(i), this.observer.observe(t), this.elementsCache.set(e, t)), (!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(s) && this.resizeItem(s, this.options.measureElement(t, void 0, this));
+    }, this.resizeItem = (t, s) => {
+      var e, i, n;
+      if (!this.isIndexInRange(t)) return;
+      let l, o, a;
+      const f = (e = this._singleLaneMeasurements) == null ? void 0 : e.flat;
+      if (this.options.lanes === 1 && f != null)
+        a = this.options.getItemKey(t), o = f[t * 2], l = f[t * 2 + 1];
+      else {
+        const m = this.measurementsCache[t];
+        if (!m) return;
+        a = m.key, o = m.start, l = m.size;
+      }
+      const c = this.itemSizeCache.get(a) ?? l, g = s - c;
+      if (g !== 0) {
+        const m = this.options.anchorTo === "end" && ((i = this.scrollState) == null ? void 0 : i.behavior) !== "smooth" && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold, b = m ? this.getTotalSize() : 0, S = this.getScrollOffset() + this.scrollAdjustments, O = !this.itemSizeCache.has(a) ? (
+          // First measurement: compensate any item whose top sits above the
+          // fold — the estimate→actual delta must be corrected regardless of
+          // scroll direction, since the whole estimated block was above it.
+          o < S
+        ) : (
+          // Re-measurement: only compensate an item that is ENTIRELY above the
+          // fold. An item that merely *spans* the fold (top above, bottom
+          // below — e.g. a streaming chat message growing at its bottom)
+          // changes size *below* the anchor point, so shifting scrollTop by the
+          // delta would drag the viewport downward on every growth (#1218).
+          // Also skip during backward scroll to avoid the "items jump while
+          // scrolling up" cascade.
+          o + c <= S && this.scrollDirection !== "backward"
+        ), u = ((n = this.scrollState) == null ? void 0 : n.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[t] ?? {
+            index: t,
+            key: a,
+            start: o,
+            size: l,
+            end: o + l,
+            lane: 0
+          },
+          g,
+          this
+        ) : O);
+        (this.pendingMin === null || t < this.pendingMin) && (this.pendingMin = t), this.itemSizeCache.set(a, s), this.itemSizeCacheVersion++;
+        let d = !1;
+        m ? d = this.applyScrollAdjustment(
+          this.getTotalSize() - b
+        ) : u && (d = this.applyScrollAdjustment(g)), this.notify(d), this._retryClampedAdjustment();
+      }
+    }, this.getVirtualItems = M(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (t, s) => {
+        const e = [];
+        for (let i = 0, n = t.length; i < n; i++) {
+          const l = t[i], o = s[l];
+          e.push(o);
+        }
+        return e;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualItemForOffset = (t) => {
+      var s;
+      const e = this.getMeasurements();
+      if (e.length === 0)
+        return;
+      const i = (s = this._singleLaneMeasurements) == null ? void 0 : s.flat, n = this.options.lanes === 1 && i != null, l = V(
+        0,
+        e.length - 1,
+        n ? (o) => i[o * 2] : (o) => W(e[o]).start,
+        t
+      );
+      return W(e[l]);
+    }, 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 t = this.scrollElement.document.documentElement;
+        return this.options.horizontal ? t.scrollWidth - this.scrollElement.innerWidth : t.scrollHeight - this.scrollElement.innerHeight;
+      }
+    }, this.getVirtualDistanceFromEnd = () => Math.max(
+      this.getTotalSize() - this.getSize() - this.getScrollOffset(),
+      0
+    ), this.getDistanceFromEnd = () => Math.max(this.getMaxScrollOffset() - this.getScrollOffset(), 0), this.isAtEnd = (t = this.options.scrollEndThreshold) => this.getDistanceFromEnd() <= t, this.getOffsetForAlignment = (t, s, e = 0) => {
+      if (!this.scrollElement) return 0;
+      const i = this.getSize(), n = this.getScrollOffset();
+      s === "auto" && (s = t >= n + i ? "end" : "start"), s === "center" ? t += (e - i) / 2 : s === "end" && (t -= i);
+      const l = this.getMaxScrollOffset();
+      return Math.max(Math.min(l, t), 0);
+    }, this.getOffsetForIndex = (t, s = "auto") => {
+      t = Math.max(0, Math.min(t, this.options.count - 1));
+      const e = this.getSize(), i = this.getScrollOffset(), n = this.measurementsCache[t];
+      if (!n) return;
+      if (s === "auto")
+        if (n.end >= i + e - this.options.scrollPaddingEnd)
+          s = "end";
+        else if (n.start <= i + this.options.scrollPaddingStart)
+          s = "start";
+        else
+          return [i, s];
+      if (s === "end" && t === this.options.count - 1)
+        return [this.getMaxScrollOffset(), s];
+      const l = s === "end" ? n.end + this.options.scrollPaddingEnd : n.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(l, s, n.size),
+        s
+      ];
+    }, this.scrollToOffset = (t, { align: s = "start", behavior: e = "auto" } = {}) => {
+      this._iosDeferredAdjustment = 0;
+      const i = this.getOffsetForAlignment(t, s), n = this.now();
+      this.scrollState = {
+        index: null,
+        align: s,
+        behavior: e,
+        startedAt: n,
+        lastTargetOffset: i,
+        stableFrames: 0
+      }, this._scrollToOffset(i, { adjustments: void 0, behavior: e }), this.scheduleScrollReconcile();
+    }, this.scrollToIndex = (t, {
+      align: s = "auto",
+      behavior: e = "auto"
+    } = {}) => {
+      this._iosDeferredAdjustment = 0, t = Math.max(0, Math.min(t, this.options.count - 1));
+      const i = this.getOffsetForIndex(t, s);
+      if (!i)
+        return;
+      const [n, l] = i, o = this.now();
+      this.scrollState = {
+        index: t,
+        align: l,
+        behavior: e,
+        startedAt: o,
+        lastTargetOffset: n,
+        stableFrames: 0
+      }, this._scrollToOffset(n, { adjustments: void 0, behavior: e }), this.scheduleScrollReconcile();
+    }, this.scrollBy = (t, { behavior: s = "auto" } = {}) => {
+      const e = this.getScrollOffset() + t, i = this.now();
+      this.scrollState = {
+        index: null,
+        align: "start",
+        behavior: s,
+        startedAt: i,
+        lastTargetOffset: e,
+        stableFrames: 0
+      }, this._scrollToOffset(e, { adjustments: void 0, behavior: s }), this.scheduleScrollReconcile();
+    }, this.scrollToEnd = ({ behavior: t = "auto" } = {}) => {
+      if (this.options.count > 0) {
+        this.scrollToIndex(this.options.count - 1, {
+          align: "end",
+          behavior: t
+        });
+        return;
+      }
+      this.scrollToOffset(Math.max(this.getTotalSize() - this.getSize(), 0), {
+        behavior: t
+      });
+    }, this.getTotalSize = () => {
+      var t, s;
+      const e = this.getMeasurements();
+      let i;
+      if (e.length === 0)
+        i = this.options.paddingStart;
+      else if (this.options.lanes === 1) {
+        const n = e.length - 1, l = (t = this._singleLaneMeasurements) == null ? void 0 : t.flat;
+        l != null ? i = l[n * 2] + l[n * 2 + 1] : i = ((s = e[n]) == null ? void 0 : s.end) ?? 0;
+      } else {
+        const n = Array(this.options.lanes).fill(null);
+        let l = e.length - 1;
+        for (; l >= 0 && n.some((o) => o === null); ) {
+          const o = e[l];
+          n[o.lane] === null && (n[o.lane] = o.end), l--;
+        }
+        i = Math.max(...n.filter((o) => o !== null));
+      }
+      return Math.max(
+        i - this.options.scrollMargin + this.options.paddingEnd,
+        0
+      );
+    }, this.takeSnapshot = () => {
+      const t = [];
+      if (this.itemSizeCache.size === 0) return t;
+      const s = this.getMeasurements();
+      for (const e of s)
+        e && this.itemSizeCache.has(e.key) && t.push({
+          index: e.index,
+          key: e.key,
+          start: e.start,
+          size: e.size,
+          end: e.end,
+          lane: e.lane
+        });
+      return t;
+    }, this._scrollToOffset = (t, {
+      adjustments: s,
+      behavior: e
+    }) => {
+      this._intendedScrollOffset = t + (s ?? 0), this.options.scrollToFn(t, { behavior: e, adjustments: s }, this);
+    }, this.measure = () => {
+      this.pendingMin = null, this.itemSizeCache.clear(), this.laneAssignments.clear(), this.itemSizeCacheVersion++, this.notify(!1);
+    }, this.setOptions(h);
+  }
+  // Returns `true` when it performed a synchronous `scrollTop` write this
+  // tick, `false` when the delta was zero or the write was deferred (iOS).
+  // `resizeItem` uses that to decide whether the follow-up `notify` must be
+  // synchronous so the grown transforms commit in the same paint (#1227).
+  applyScrollAdjustment(h, t) {
+    if (h === 0) return !1;
+    if (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", h), F() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded))
+      return this._iosDeferredAdjustment += h, !1;
+    {
+      const s = this.getScrollOffset() + this.scrollAdjustments + h, e = this.scrollElement, i = e !== null && ("scrollHeight" in e || "document" in e) ? this.getMaxScrollOffset() : null;
+      return this._clampedAdjustment = i !== null && s > i + 0.5 ? { target: s, maxAtWrite: i } : null, this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += h,
+        behavior: t
+      }), this.scrollOffset !== null && (this.scrollOffset += this.scrollAdjustments, this.scrollOffset < 0 && (this.scrollOffset = 0), this.scrollAdjustments = 0), !0;
+    }
+  }
+  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, e = s ? s[0] : this.scrollState.lastTargetOffset, i = 1, n = e !== this.scrollState.lastTargetOffset;
+    if (!n && L(e, this.getScrollOffset())) {
+      if (this.scrollState.stableFrames++, this.scrollState.stableFrames >= i) {
+        this.getScrollOffset() !== e && this._scrollToOffset(e, {
+          adjustments: void 0,
+          behavior: "auto"
+        }), this.scrollState = null;
+        return;
+      }
+    } else if (this.scrollState.stableFrames = 0, n) {
+      const l = this.getSize() || 600, o = Math.abs(e - this.getScrollOffset()), a = this.scrollState.behavior === "smooth" && o > l;
+      this.scrollState.lastTargetOffset = e, a || (this.scrollState.behavior = "auto"), this._scrollToOffset(e, {
+        adjustments: void 0,
+        behavior: a ? "smooth" : "auto"
+      });
+    }
+    this.scheduleScrollReconcile();
+  }
+}
+const V = (r, h, t, s) => {
+  for (; r <= h; ) {
+    const e = (r + h) / 2 | 0, i = t(e);
+    if (i < s)
+      r = e + 1;
+    else if (i > s)
+      h = e - 1;
+    else
+      return e;
+  }
+  return r > 0 ? r - 1 : 0;
+};
+function G(r, h, t) {
+  let s = 0;
+  for (; s <= h; ) {
+    const e = (s + h) / 2 | 0, i = r[e * 2];
+    if (i < t)
+      s = e + 1;
+    else if (i > t)
+      h = e - 1;
+    else
+      return e;
+  }
+  return s > 0 ? s - 1 : 0;
+}
+function Q(r, h, t, s, e) {
+  const i = r.length - 1;
+  if (r.length <= s)
+    return { startIndex: 0, endIndex: i };
+  if (s === 1 && e !== null) {
+    const a = G(
+      e,
+      i,
+      t
+    );
+    let f = a;
+    const c = t + h;
+    for (; f < i && e[f * 2] + e[f * 2 + 1] < c; )
+      f++;
+    return { startIndex: a, endIndex: f };
+  }
+  let l = V(0, i, (a) => r[a].start, t), o = l;
+  if (s === 1)
+    for (; o < i && r[o].end < t + h; )
+      o++;
+  else if (s > 1) {
+    const a = Array(s).fill(0);
+    for (; o < i && a.some((c) => c < t + h); ) {
+      const c = r[o];
+      a[c.lane] = c.end, o++;
+    }
+    const f = Array(s).fill(t + h);
+    for (; l >= 0 && f.some((c) => c >= t); ) {
+      const c = r[l];
+      f[c.lane] = c.start, l--;
+    }
+    l = Math.max(0, l - l % s), o = Math.min(i, o + (s - 1 - o % s));
+  }
+  return { startIndex: l, endIndex: o };
+}
+export {
+  it as Virtualizer,
+  L as approxEqual,
+  P as debounce,
+  B as defaultKeyExtractor,
+  H as defaultRangeExtractor,
+  st as elementScroll,
+  U as measureElement,
+  M as memo,
+  W as notUndefined,
+  et as observeElementOffset,
+  tt as observeElementRect
+};