x-sccba 0.1.1 → 0.2.3

package/dist/vue3/index250.mjs

@@ -0,0 +1,936 @@
+import { computed, toValue, ref, onMounted, nextTick, onActivated, onBeforeUnmount, watch, markRaw, shallowReactive } from "vue";
+import { r as f } from "./index258.mjs";
+function st(n, o, s) {
+  return f(n, o, s);
+}
+function Be(n, o) {
+  return n.map((s, u) => st(s, u, o));
+}
+function wn(n, o, s) {
+  const u = [], l = [];
+  for (let f2 = 0; f2 < n.length; f2++) {
+    const I = n[f2], x = st(I, f2, o), T = s(I, f2, x);
+    u.push(x), l.push(typeof T == "number" && T > 0 ? T : null);
+  }
+  return {
+    keys: u,
+    sizes: l
+  };
+}
+function xn(n, o, s) {
+  if (!n || n.keys.length !== o.length || n.sizes.length !== o.length)
+    return false;
+  for (let u = 0; u < o.length; u++)
+    if (n.keys[u] !== st(o[u], u, s))
+      return false;
+  return true;
+}
+function bn(n, o, s) {
+  if (!xn(n, o, s))
+    return {};
+  const u = {};
+  for (let l = 0; l < n.keys.length; l++) {
+    const f2 = n.sizes[l];
+    typeof f2 == "number" && f2 > 0 && (u[n.keys[l]] = f2);
+  }
+  return u;
+}
+function zn(n, o) {
+  if (!n.length || o.length <= n.length)
+    return 0;
+  const s = n[0], u = o.indexOf(s);
+  if (u <= 0 || u + n.length < o.length && n.length > o.length - u)
+    return 0;
+  for (let l = 0; l < n.length; l++)
+    if (o[u + l] !== n[l])
+      return 0;
+  return u;
+}
+function At(n, o, s, u, l, f2 = 0) {
+  const I = l ?? "start";
+  if (I === "nearest") {
+    const x = s + u, T = n + o;
+    return n >= s && T <= x ? null : n < s ? n + f2 : T - u + f2;
+  }
+  return I === "end" ? n + o - u + f2 : I === "center" ? n + (o - u) / 2 + f2 : n + f2;
+}
+function Mn(n) {
+  return n.flowMode && n.direction === "vertical" && !n.gridItems ? "flow" : n.disableTransform ? "position" : "transform";
+}
+function Tn(n, o) {
+  const s = o.direction === "vertical", u = o.mode ?? "transform", l = {
+    visibility: n.nr.used ? "visible" : "hidden",
+    pointerEvents: n.nr.used ? void 0 : "none"
+  };
+  if (u === "flow" ? l.display = n.nr.used ? void 0 : "none" : (l.position = "absolute", l.top = "0px", l.left = "0px", l.display = void 0), u === "position" ? (l[s ? "top" : "left"] = `${n.position}px`, l[s ? "left" : "top"] = `${n.offset}px`, l.transform = "none", l.willChange = "unset") : u === "transform" && (l.transform = s ? `translateY(${n.position}px) translateX(${n.offset}px)` : `translateX(${n.position}px) translateY(${n.offset}px)`, l.willChange = "transform"), o.gridItems && o.itemSize != null) {
+    const f2 = o.itemSecondarySize || o.itemSize;
+    l.width = `${s ? f2 : o.itemSize}px`, l.height = `${s ? o.itemSize : f2}px`;
+  }
+  return l;
+}
+function Ut(n) {
+  return computed(() => toValue(n));
+}
+function En(n, o, s, u, l) {
+  const f2 = Ut(n);
+  return {
+    el: computed(() => {
+      const I = f2.value.el;
+      return toValue(o ?? I);
+    }),
+    before: computed(() => {
+      const I = f2.value.before;
+      return toValue(s ?? I);
+    }),
+    after: computed(() => {
+      const I = f2.value.after;
+      return toValue(u ?? I);
+    }),
+    scrollParent: computed(() => {
+      const I = f2.value.scrollParent;
+      return toValue(I);
+    }),
+    callbacks: {
+      onResize: () => {
+        var I;
+        return (I = (l == null ? void 0 : l.onResize) ?? f2.value.onResize) == null ? void 0 : I();
+      },
+      onVisible: () => {
+        var I;
+        return (I = (l == null ? void 0 : l.onVisible) ?? f2.value.onVisible) == null ? void 0 : I();
+      },
+      onHidden: () => {
+        var I;
+        return (I = (l == null ? void 0 : l.onHidden) ?? f2.value.onHidden) == null ? void 0 : I();
+      },
+      onUpdate: (I, x, T, N) => {
+        var ge;
+        return (ge = (l == null ? void 0 : l.onUpdate) ?? f2.value.onUpdate) == null ? void 0 : ge(I, x, T, N);
+      }
+    }
+  };
+}
+const Vn = {
+  itemsLimit: 1e3
+};
+function $t(n) {
+  return typeof window < "u" && n === window;
+}
+const _n = (() => {
+  if (typeof document > "u")
+    return "negative";
+  const n = document.createElement("div"), o = document.createElement("div");
+  n.style.width = "4px", n.style.height = "1px", n.style.overflow = "auto", n.style.direction = "rtl", o.style.width = "8px", o.style.height = "1px", n.appendChild(o), document.body.appendChild(n), n.scrollLeft = -1;
+  const s = n.scrollLeft < 0;
+  return document.body.removeChild(n), s ? "negative" : "default";
+})();
+function pe(n, o, s) {
+  return o !== "horizontal" || !s || $t(s) || getComputedStyle(s).direction !== "rtl" ? n : _n === "negative" ? -n : n;
+}
+function Pn(n, o, s) {
+  return pe(n, o, s);
+}
+function it(n, o, s, u) {
+  const l = Pn(s, o, n), f2 = !!(u != null && u.smooth);
+  if ($t(n)) {
+    o === "vertical" ? n.scrollTo({
+      top: l,
+      behavior: f2 ? "smooth" : "auto"
+    }) : n.scrollTo({
+      left: l,
+      behavior: f2 ? "smooth" : "auto"
+    });
+    return;
+  }
+  if (typeof n.scrollTo == "function") {
+    n.scrollTo(o === "vertical" ? { top: l, behavior: f2 ? "smooth" : "auto" } : { left: l, behavior: f2 ? "smooth" : "auto" });
+    return;
+  }
+  o === "vertical" ? n.scrollTop = l : n.scrollLeft = l;
+}
+function Fn(n, o, s, u) {
+  if (s) {
+    if (u && u !== window) {
+      const l = u;
+      return o === "vertical" ? l.clientHeight : l.clientWidth;
+    }
+    return o === "vertical" ? window.innerHeight : window.innerWidth;
+  }
+  return o === "vertical" ? n.clientHeight : n.clientWidth;
+}
+const Ln = /auto|scroll/;
+function jt(n, o) {
+  return n.parentNode === null ? o : jt(n.parentNode, [...o, n]);
+}
+function ot(n, o) {
+  return getComputedStyle(n, null).getPropertyValue(o);
+}
+function Cn(n) {
+  return ot(n, "overflow") + ot(n, "overflow-y") + ot(n, "overflow-x");
+}
+function Rn(n) {
+  return Ln.test(Cn(n));
+}
+function Wn(n) {
+  if (!(n instanceof HTMLElement || n instanceof SVGElement))
+    return;
+  if (n.parentNode === null)
+    return document.scrollingElement || document.documentElement;
+  const o = jt(n.parentNode, []);
+  for (let s = 0; s < o.length; s += 1)
+    if (o[s] instanceof Element && Rn(o[s]))
+      return o[s];
+  return document.scrollingElement || document.documentElement;
+}
+function kn(n, o) {
+  if (o)
+    return o;
+  if (!n)
+    return;
+  const s = Wn(n);
+  if (s)
+    return typeof window < "u" && window.document && (s === window.document.documentElement || s === window.document.body) ? window : s;
+}
+let lt = false;
+function Nn() {
+  return lt;
+}
+if (typeof window < "u") {
+  lt = false;
+  try {
+    const n = Object.defineProperty({}, "passive", {
+      get() {
+        lt = true;
+      }
+    });
+    window.addEventListener("test", null, n);
+  } catch {
+  }
+}
+function D(n) {
+  return typeof n == "number" ? n : null;
+}
+function Hn(n, o, s, u, l) {
+  return typeof s == "number" ? s : typeof s == "function" ? s(n, o) || u || void 0 : u || (n == null ? void 0 : n[l ?? "size"]) || void 0;
+}
+function An(n, o, s, u, l, f2) {
+  return typeof s == "function" ? s(n, o) || u || Number(l) || 0 : u || (n == null ? void 0 : n[f2 ?? "size"]) || Number(l) || 0;
+}
+let Bn = 0;
+const Yn = [];
+function On(n) {
+  for (let o = 0; o < n.length; o++)
+    n[o];
+}
+function Un(n, o) {
+  return n && typeof n == "object" ? n[o] : void 0;
+}
+function Ye(n, o) {
+  return n.map((s) => Un(s, o));
+}
+function $n(n, o, s, u) {
+  if (n.length !== s.length || o.length !== u.length)
+    return false;
+  for (let l = 0; l < n.length; l++)
+    if (n[l] !== s[l] || o[l] !== u[l])
+      return false;
+  return true;
+}
+function jn(n) {
+  const o = n;
+  o._vs_styleStamp++;
+}
+function Bt(n) {
+  const o = n;
+  o._vs_visibilityStamp++, o._vs_styleStamp++;
+}
+function Dn(n, o, s, u) {
+  if (s) {
+    for (const l of s)
+      u(l);
+    return;
+  }
+  for (let l = n; l < o; l++)
+    u(l);
+}
+const Yt = 8, Ot = 1;
+function qn(n, o, s, u, l, f$1) {
+  const I = Ut(n), x = En(I, o, s, u, l), T = computed(() => {
+    const e = toValue(v().items);
+    return On(e), e;
+  }), N = ref([]), ge = ref(0), Se = ref(0), ye = ref(0), le = ref(false);
+  let G = 0, X = 0, at = 0, ut = 0, ct = false, ee = null;
+  const Ue = /* @__PURE__ */ new Map(), $e = /* @__PURE__ */ new Map();
+  let Ee = false, je = 0, dt = 0, De = false, se = null, ae = null, q = null, Ge = 0, Ie = null, we = null, Ve = [], xe = [], te = null, Y = null, be = null, Xe = false, ft = false, mt = false;
+  const _e = /* @__PURE__ */ new Set(), Pe = ref({}), qe = [], ht = {
+    accumulator: 0
+  };
+  function v() {
+    return I.value;
+  }
+  function ue() {
+    return (f$1 == null ? void 0 : f$1.pageMode) ?? v().pageMode;
+  }
+  const M = computed(() => toValue(v().enabled ?? true)), ze = computed(() => kn(
+    x.el.value,
+    x.scrollParent.value
+  )), Z = computed(() => {
+    const e = T.value;
+    return e.length > 0 && typeof e[0] != "object";
+  }), Me = computed(() => {
+    const e = v();
+    if (D(e.itemSize) === null) {
+      const r = T.value, i = Array.from({ length: r.length });
+      ht.accumulator = 0, i[-1] = ht;
+      const a = e.minItemSize, d = Pe.value, h = Z.value;
+      let S = 1e4, p = 0, z;
+      for (let c = 0, m = r.length; c < m; c++) {
+        const V = h ? c : f(r[c], c, e.keyField);
+        z = An(
+          r[c],
+          c,
+          e.itemSize,
+          d[V],
+          a,
+          e.sizeField
+        ), z < S && (S = z), p += z;
+        const E = qe[c] ?? (qe[c] = {
+          accumulator: 0,
+          size: void 0
+        });
+        E.accumulator = p, E.size = z, i[c] = E;
+      }
+      return qe.length = r.length, Ge = S, i;
+    }
+    return Yn;
+  }), Dt = computed(
+    () => N.value.filter((e) => (e._vs_visibilityStamp, e.nr.used)).sort((e, t) => e.nr.index - t.nr.index)
+  ), Gt = computed(() => {
+    const e = v(), t = Z.value ? null : e.keyField;
+    return wn(T.value, t, (r, i, a) => Hn(
+      r,
+      i,
+      e.itemSize,
+      Pe.value[a],
+      e.sizeField
+    ));
+  });
+  function J(e = v()) {
+    return e.direction ?? "vertical";
+  }
+  function ce(e = v()) {
+    const t = J(e);
+    let r = e.flowMode ?? false;
+    return r && t !== "vertical" && (ft || (console.warn("[vue-recycle-scroller] flowMode only supports vertical lists. Falling back to standard positioning."), ft = true), r = false), r && e.gridItems && (mt || (console.warn("[vue-recycle-scroller] flowMode does not support gridItems. Falling back to standard positioning."), mt = true), r = false), Mn({
+      direction: t,
+      disableTransform: e.disableTransform ?? false,
+      flowMode: r,
+      gridItems: e.gridItems
+    });
+  }
+  function vt() {
+    N.value.sort((e, t) => e.nr.used !== t.nr.used ? e.nr.used ? -1 : 1 : e.nr.used && t.nr.used ? e.nr.index - t.nr.index : e.nr.id - t.nr.id);
+  }
+  function Ze(e) {
+    const t = v();
+    return Pe.value = bn(e, T.value, Z.value ? null : t.keyField), Object.keys(Pe.value).length > 0;
+  }
+  function pt(e) {
+    let t = $e.get(e);
+    return t || (t = [], $e.set(e, t)), t;
+  }
+  function Xt(e, t, r, i, a) {
+    const d = markRaw({
+      id: Bn++,
+      index: t,
+      used: true,
+      key: i,
+      type: a
+    }), h = shallowReactive({
+      item: r,
+      position: 0,
+      offset: 0,
+      nr: d,
+      _vs_styleStamp: 0,
+      _vs_visibilityStamp: 0
+    });
+    return e.push(h), h;
+  }
+  function qt(e) {
+    const t = pt(e);
+    if (t && t.length) {
+      const r = t.pop();
+      return r.nr.used = true, Bt(r), r;
+    }
+  }
+  function gt(e, t) {
+    const r = N.value, i = r.indexOf(e);
+    if (i === -1)
+      return;
+    const a = Math.max(0, Math.min(t, r.length - 1));
+    i !== a && (r.splice(i, 1), r.splice(a, 0, e));
+  }
+  function Zt(e) {
+    gt(e, N.value.length - 1);
+  }
+  function Jt() {
+    const e = N.value;
+    let t = 0;
+    for (; t < e.length && !e[t].nr.used; )
+      t++;
+    let r = 0;
+    for (let i = t; i < e.length && e[i].nr.used; i++)
+      r++;
+    return {
+      activeStart: t,
+      activeCount: r,
+      headInsertCount: 0
+    };
+  }
+  function Qt(e, t, r) {
+    let i = null;
+    t < G ? (i = r.activeStart + r.headInsertCount, r.headInsertCount++, r.activeCount++) : t >= X && (i = r.activeStart + r.activeCount, r.activeCount++), i != null && gt(e, i);
+  }
+  function St(e, t = false) {
+    const r = e.nr.type;
+    pt(r).push(e), e.nr.used = false, e.position = v().hiddenPosition ?? -999999, Bt(e), Ue.delete(e.nr.key), t && Zt(e);
+  }
+  function Kt() {
+    Ue.clear(), $e.clear();
+    for (let e = 0, t = N.value.length; e < t; e++) {
+      const r = N.value[e];
+      r && St(r);
+    }
+  }
+  function Je(e) {
+    let t = -1;
+    return t = requestAnimationFrame(() => {
+      _e.delete(t), e();
+    }), _e.add(t), t;
+  }
+  function yt() {
+    for (const e of _e)
+      cancelAnimationFrame(e);
+    _e.clear();
+  }
+  function It() {
+    se && (clearTimeout(se), se = null), ae && (clearTimeout(ae), ae = null), q && (clearTimeout(q), q = null), Y && (clearTimeout(Y), Y = null), be && (clearTimeout(be), be = null);
+  }
+  function Qe() {
+    var e, t;
+    M.value && ((t = (e = x.callbacks).onResize) == null || t.call(e), le.value && L(false));
+  }
+  function Ke() {
+    if (!M.value)
+      return;
+    te && !Xe && ne();
+    const e = v();
+    if (!Ee) {
+      if (Ee = true, se)
+        return;
+      const t = () => Je(() => {
+        Ee = false;
+        const { continuous: r } = L(false, true);
+        r || (ae && clearTimeout(ae), ae = setTimeout(Ke, e.updateInterval + 100));
+      });
+      t(), e.updateInterval && (se = setTimeout(() => {
+        se = null, Ee && t();
+      }, e.updateInterval));
+    }
+  }
+  function en(e, t) {
+    var r, i, a, d;
+    M.value && le.value && (e || t.boundingClientRect.width !== 0 || t.boundingClientRect.height !== 0 ? ((i = (r = x.callbacks).onVisible) == null || i.call(r), Je(() => {
+      L(false);
+    })) : (d = (a = x.callbacks).onHidden) == null || d.call(a));
+  }
+  function tn() {
+    return ze.value ?? window;
+  }
+  function Fe() {
+    const e = x.before.value;
+    if (!e)
+      return 0;
+    const t = v();
+    return J(t) === "vertical" ? e.scrollHeight : e.scrollWidth;
+  }
+  function de() {
+    const e = x.el.value;
+    if (!e)
+      return { start: 0, end: 0 };
+    const t = v(), r = J(t), i = r === "vertical";
+    let a;
+    if (ue()) {
+      const d = e.getBoundingClientRect(), h = i ? d.height : d.width, S = ze.value, p = !S || S === window, z = p ? 0 : S.getBoundingClientRect().top, c = p ? 0 : S.getBoundingClientRect().left, m = p ? window.innerHeight : S.clientHeight, V = p ? window.innerWidth : S.clientWidth;
+      let E = i ? -(d.top - z) : -(d.left - c), W = i ? m : V;
+      E < 0 && (W += E, E = 0), E + W > h && (W = h - E), a = {
+        start: E,
+        end: E + W
+      };
+    } else i ? a = {
+      start: e.scrollTop,
+      end: e.scrollTop + e.clientHeight
+    } : a = {
+      start: pe(e.scrollLeft, r, e),
+      end: pe(e.scrollLeft, r, e) + e.clientWidth
+    };
+    return a;
+  }
+  function nn() {
+    const e = x.el.value;
+    if (!e)
+      return { start: 0, end: 0 };
+    const t = v();
+    if (J(t) === "vertical") {
+      const r = pe(e.scrollLeft, "horizontal", e);
+      return {
+        start: r,
+        end: r + e.clientWidth
+      };
+    }
+    return {
+      start: e.scrollTop,
+      end: e.scrollTop + e.clientHeight
+    };
+  }
+  function rn(e, t, r, i) {
+    var S, p, z, c;
+    const a = Fe(), d = e.start - i - a, h = e.end + i - a;
+    if (G > 0) {
+      const m = ((S = r[G - 1]) == null ? void 0 : S.accumulator) ?? 0;
+      if (d <= m)
+        return true;
+    }
+    if (G < t - 1) {
+      const m = ((p = r[G]) == null ? void 0 : p.accumulator) ?? Number.POSITIVE_INFINITY;
+      if (d > m)
+        return true;
+    }
+    if (X > 1) {
+      const m = ((z = r[X - 2]) == null ? void 0 : z.accumulator) ?? 0;
+      if (h <= m)
+        return true;
+    }
+    if (X < t) {
+      const m = ((c = r[X - 1]) == null ? void 0 : c.accumulator) ?? Number.POSITIVE_INFINITY;
+      if (h > m)
+        return true;
+    }
+    return false;
+  }
+  function Le(e) {
+    const t = v(), r = D(t.itemSize);
+    if (r !== null)
+      return r;
+    const i = Me.value[e];
+    return (i == null ? void 0 : i.size) || Number(t.minItemSize) || 0;
+  }
+  function on(e) {
+    const t = v();
+    return Tn(e, {
+      direction: J(t),
+      mode: ce(t),
+      itemSize: D(t.itemSize),
+      gridItems: t.gridItems,
+      itemSecondarySize: t.itemSecondarySize
+    });
+  }
+  function U(e) {
+    var a;
+    const t = v(), r = t.gridItems || 1, i = D(t.itemSize);
+    return e <= 0 ? 0 : i !== null ? Math.floor(e / r) * i : ((a = Me.value[e - 1]) == null ? void 0 : a.accumulator) || 0;
+  }
+  function wt(e) {
+    const t = v(), r = T.value.length, i = t.gridItems || 1, a = D(t.itemSize);
+    if (!r)
+      return 0;
+    if (a !== null) {
+      const p = Math.floor(e / a) * i;
+      return Math.min(Math.max(p, 0), r - 1);
+    }
+    let d = 0, h = r - 1, S = 0;
+    for (; d <= h; ) {
+      const p = Math.floor((d + h) / 2);
+      U(p) <= e ? (S = p, d = p + 1) : h = p - 1;
+    }
+    return S;
+  }
+  function ne() {
+    Y && (clearTimeout(Y), Y = null), te = null;
+  }
+  function ln() {
+    Y && clearTimeout(Y), Y = setTimeout(() => {
+      te = null, Y = null;
+    }, 150);
+  }
+  function sn(e, t) {
+    if (!e.length) {
+      ne();
+      return;
+    }
+    const r = Math.max(de().start - Fe(), 0), i = Math.min(wt(r), e.length - 1), a = e[i], d = t ? f(a, i, t) : i, h = Fe() + U(i);
+    te = {
+      key: d,
+      offset: de().start - h
+    };
+  }
+  function xt(e) {
+    if (!te)
+      return false;
+    const t = v(), r = e ?? T.value, i = Z.value ? null : t.keyField, d = Be(r, i).indexOf(te.key);
+    if (d === -1)
+      return ne(), false;
+    const h = Fe() + U(d) + te.offset, S = de().start;
+    return Math.abs(h - S) < 0.5 ? false : (Xe = true, Ce(h), Je(() => {
+      Xe = false;
+    }), true);
+  }
+  function Te() {
+    if (fe(), !M.value)
+      return;
+    const e = ue() ? tn() : x.el.value;
+    e && (Ie = e, Ie.addEventListener("scroll", Ke, Nn() ? { passive: true } : false), ue() && e === window && (we = e, we.addEventListener("resize", Qe)));
+  }
+  function fe() {
+    Ie && (Ie.removeEventListener("scroll", Ke), Ie = null), we && (we.removeEventListener("resize", Qe), we = null);
+  }
+  function an(e, t, r, i, a, d) {
+    const h = Math.ceil(e / t) * r, S = Math.max(0, Math.floor(a.start / r)), p = Math.min(Math.ceil(a.end / r), Math.ceil(e / t)), z = Math.max(0, Math.floor(d.start / i)), c = Math.min(Math.ceil(d.end / i), t), m = [];
+    for (let W = S; W < p; W++) {
+      const me = W * t;
+      for (let w = z; w < c; w++) {
+        const g = me + w;
+        if (g >= e)
+          break;
+        m.push(g);
+      }
+    }
+    const V = m[0] ?? 0, E = m.at(-1) ?? -1;
+    return {
+      renderedIndices: m,
+      startIndex: V,
+      endIndex: E + 1,
+      visibleStartIndex: V,
+      visibleEndIndex: E,
+      totalSize: h
+    };
+  }
+  function un() {
+    const e = v(), t = D(e.itemSize);
+    if (!e.gridItems || t == null)
+      return false;
+    const r = x.el.value;
+    if (!r)
+      return false;
+    const i = e.itemSecondarySize || t, a = J(e) === "vertical" ? r.clientWidth : r.clientHeight;
+    return i * e.gridItems > a;
+  }
+  function bt(e, t, r, i) {
+    if (Math.abs(e - t) !== 1 || t < 0 || t >= r)
+      return e;
+    const a = e > t ? U(t) + Le(t) : U(t);
+    return Math.abs(a - i) <= Yt ? t : e;
+  }
+  function zt(e, t, r, i, a) {
+    if (Math.abs(e - t) !== 1)
+      return e;
+    const d = a ? t - 1 : t;
+    if (d < 0 || d >= r)
+      return e;
+    const h = e > t ? U(d) + Le(d) : U(d);
+    return Math.abs(h - i) <= Yt ? t : e;
+  }
+  function cn(e, t, r) {
+    const i = {
+      ...e,
+      visibleStartIndex: bt(e.visibleStartIndex, at, t, r.rawViewportStart),
+      visibleEndIndex: zt(e.visibleEndIndex, ut, t, r.rawViewportEnd, false),
+      startIndex: bt(e.startIndex, G, t, r.renderStart),
+      endIndex: zt(e.endIndex, X, t, r.renderEnd, true)
+    };
+    i.startIndex > i.visibleStartIndex && (i.startIndex = i.visibleStartIndex);
+    const a = Math.min(t, i.visibleEndIndex + 1);
+    return i.endIndex < a && (i.endIndex = a), i.endIndex < i.startIndex && (i.endIndex = i.startIndex), i;
+  }
+  function L(e, t = false) {
+    var Vt, _t, Pt, Ft, Lt, Ct, Rt, Wt, kt;
+    if (!M.value)
+      return { continuous: true };
+    const r = v(), i = D(r.itemSize), a = r.gridItems || 1, d = r.itemSecondarySize || i || 0, h = Ge, S = r.typeField, p = Z.value ? null : r.keyField, z = T.value, c = z.length, m = Me.value, V = Ue, E = N.value;
+    let W = null, me = null, w, g, H, _, P;
+    const hn = i !== null || c === 0 || m[c - 1] != null;
+    if (!c || !hn)
+      !c || !ee ? w = g = _ = P = H = 0 : (w = Math.min(ee.startIndex, c), g = Math.min(ee.endIndex, c), _ = Math.min(ee.visibleStartIndex, c), P = Math.min(ee.visibleEndIndex, c), H = ((Vt = m[c - 1]) == null ? void 0 : Vt.accumulator) ?? ee.totalSizeValue);
+    else if (De)
+      w = _ = 0, g = P = Math.min(r.prerender, z.length), H = 0;
+    else {
+      const b = de(), R = nn(), $ = je, j = dt, C = { ...b }, he = { ...R };
+      if (t) {
+        let F = b.start - $;
+        F < 0 && (F = -F);
+        let oe = R.start - j;
+        oe < 0 && (oe = -oe);
+        const Ne = i === null && rn(b, c, m, r.buffer), k = i === null && (F >= h || Ne) || i !== null && F >= i, He = a > 1 && i != null && oe >= d;
+        if (!k && !He)
+          return {
+            continuous: true
+          };
+      }
+      je = b.start, dt = R.start;
+      const Q = r.buffer;
+      C.start -= Q, C.end += Q, he.start -= Q, he.end += Q;
+      let O = 0;
+      const Nt = x.before.value;
+      Nt && (O = Nt.scrollHeight, C.start -= O);
+      const Ht = x.after.value;
+      if (Ht) {
+        const F = Ht.scrollHeight;
+        C.end += F;
+      }
+      const vn = ce(r) === "flow" && i === null && !t && ct && Math.abs(b.start - $) <= Ot && Math.abs(R.start - j) <= Ot;
+      if (i === null) {
+        let F, oe = 0, Ne = c - 1, k = ~~(c / 2), He;
+        do
+          He = k, F = ((_t = m[k]) == null ? void 0 : _t.accumulator) ?? 0, F < C.start ? oe = k : k < c - 1 && (((Pt = m[k + 1]) == null ? void 0 : Pt.accumulator) ?? Number.POSITIVE_INFINITY) > C.start && (Ne = k), k = ~~((oe + Ne) / 2);
+        while (k !== He);
+        for (k < 0 && (k = 0), w = k, H = ((Ft = m[c - 1]) == null ? void 0 : Ft.accumulator) ?? 0, g = k; g < c && (((Lt = m[g]) == null ? void 0 : Lt.accumulator) ?? 0) < C.end; g++) ;
+        for (g === -1 ? g = z.length - 1 : (g++, g > c && (g = c)), _ = w; _ < c && O + (((Ct = m[_]) == null ? void 0 : Ct.accumulator) ?? Number.POSITIVE_INFINITY) < C.start; _++) ;
+        for (P = _; P < c && O + (((Rt = m[P]) == null ? void 0 : Rt.accumulator) ?? 0) < C.end; P++) ;
+        if (vn) {
+          const Ae = cn({
+            startIndex: w,
+            endIndex: g,
+            visibleStartIndex: _,
+            visibleEndIndex: P
+          }, c, {
+            rawViewportStart: b.start - O,
+            rawViewportEnd: b.end - O,
+            renderStart: b.start - Q - O,
+            renderEnd: b.end + Q - O
+          });
+          w = Ae.startIndex, g = Ae.endIndex, _ = Ae.visibleStartIndex, P = Ae.visibleEndIndex;
+        }
+        ee = {
+          startIndex: w,
+          endIndex: g,
+          visibleStartIndex: _,
+          visibleEndIndex: P,
+          totalSizeValue: H
+        };
+      } else if (a > 1) {
+        const F = an(
+          c,
+          a,
+          i,
+          d,
+          C,
+          he
+        );
+        W = F.renderedIndices, me = new Set(W), w = F.startIndex, g = F.endIndex, _ = F.visibleStartIndex, P = F.visibleEndIndex, H = F.totalSize;
+      } else {
+        w = ~~(C.start / i * a);
+        const F = w % a;
+        w -= F, g = Math.ceil(C.end / i * a), _ = Math.max(0, Math.floor((C.start - O) / i * a)), P = Math.floor((C.end - O) / i * a), w < 0 && (w = 0), g > c && (g = c), _ < 0 && (_ = 0), P > c && (P = c), H = Math.ceil(c / a) * i;
+      }
+    }
+    g - w > Vn.itemsLimit && dn(), ge.value = H, Se.value = 0, ye.value = ce(r) === "flow" ? H : 0;
+    let y;
+    const et = w <= X && g >= G, Tt = ce(r) === "flow", tt = Tt && et && !e;
+    let nt = null;
+    if (!et || e)
+      Kt();
+    else {
+      const b = (R) => {
+        const $ = E[R];
+        $ && (y = $, y.nr.used && ((me ? me.has(y.nr.index) : y.nr.index >= w && y.nr.index < g) || St(y, tt)));
+      };
+      if (tt) {
+        for (let R = E.length - 1; R >= 0; R--)
+          b(R);
+        nt = Jt();
+      } else
+        for (let R = 0, $ = E.length; R < $; R++)
+          b(R);
+    }
+    let ie, We, ke = null, Et = 0;
+    return Dn(w, g, W, (b) => {
+      var he;
+      const R = m[b] && m[b].size, $ = i || R || Ge || 1;
+      ie = z[b];
+      const j = p ? f(ie, b, p) : b;
+      y = V.get(j);
+      let C = false;
+      if (y)
+        y.item !== ie && (y.item = ie), y.nr.used || console.warn(`Expected existing view's used flag to be true, got ${y.nr.used}`);
+      else {
+        if (We = ie[S], y = qt(We), y) {
+          const Q = y.nr.index !== b || y.nr.key !== j;
+          y.item = ie, y.nr.index = b, y.nr.key = j, y.nr.type !== We && console.warn("Reused view's type does not match pool's type"), Q && jn(y);
+        } else
+          y = Xt(E, b, ie, j, We);
+        V.set(j, y), C = true;
+      }
+      i === null ? (y.position = ((he = m[b - 1]) == null ? void 0 : he.accumulator) || 0, y.offset = 0) : (y.position = Math.floor(b / a) * i, y.offset = b % a * d), nt && C && Qt(y, b, nt), ke ?? (ke = y.position), Et += $;
+    }), Tt ? (ke == null ? (Se.value = 0, ye.value = H) : (Se.value = ke, ye.value = Math.max(0, H - ke - Et)), tt || vt()) : (Se.value = 0, ye.value = 0), G = w, X = g, at = _, ut = P, ct = true, r.emitUpdate && ((kt = (Wt = x.callbacks).onUpdate) == null || kt.call(Wt, w, g, _, P)), ce(r) !== "flow" && (q && clearTimeout(q), q = setTimeout(Mt, r.updateInterval + 300)), {
+      continuous: et
+    };
+  }
+  function dn() {
+    throw be = setTimeout(() => {
+      be = null, console.warn("It seems the scroller element isn't scrolling, so it tries to render all the items at once.", "Scroller:", x.el.value), console.warn("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.");
+    }), new Error("Rendered items limit reached");
+  }
+  function fn() {
+    if (un())
+      return false;
+    const e = N.value.filter(({ nr: t }) => t.used);
+    for (let t = 1; t < e.length; t++)
+      if (e[t].nr.index !== e[t - 1].nr.index + 1)
+        return true;
+    return false;
+  }
+  function Mt() {
+    if (M.value) {
+      if (ce() === "flow") {
+        vt();
+        return;
+      }
+      N.value.sort((e, t) => e.nr.index - t.nr.index), fn() && (L(false), q && clearTimeout(q));
+    }
+  }
+  function mn(e, t) {
+    if (!M.value)
+      return;
+    const r = v(), i = J(r), a = x.el.value;
+    if (!a)
+      return;
+    const d = Math.max(0, Math.min(e, T.value.length - 1)), h = de().start, S = Fn(a, i, r.pageMode, ze.value), p = U(d), z = Le(d), c = At(
+      p,
+      z,
+      h,
+      S,
+      t == null ? void 0 : t.align,
+      (t == null ? void 0 : t.offset) ?? 0
+    );
+    if (c == null)
+      return;
+    Ce(c, t);
+    const m = D(r.itemSize);
+    if (r.gridItems && m != null) {
+      const V = x.el.value;
+      if (!V)
+        return;
+      const E = r.gridItems, W = r.itemSecondarySize || m, w = d % E * W, g = i === "vertical" ? "horizontal" : "vertical", H = g === "horizontal" ? pe(V.scrollLeft, "horizontal", V) : V.scrollTop, _ = g === "horizontal" ? V.clientWidth : V.clientHeight, P = At(
+        w,
+        W,
+        H,
+        _,
+        t == null ? void 0 : t.align,
+        (t == null ? void 0 : t.offset) ?? 0
+      );
+      P != null && it(V, g, P, t);
+    }
+  }
+  function Ce(e, t) {
+    if (!M.value)
+      return;
+    const r = v(), i = J(r), a = x.el.value;
+    if (a)
+      if (ue()) {
+        const d = ze.value ?? window, h = i === "vertical" ? "top" : "left", S = d === window, p = S ? document.scrollingElement || document.documentElement : d, z = p.getBoundingClientRect(), c = a.getBoundingClientRect(), m = S ? i === "vertical" ? window.scrollY : window.scrollX : pe(
+          i === "vertical" ? p.scrollTop : p.scrollLeft,
+          i,
+          p
+        ), V = c[h] - z[h];
+        it(S ? window : p, i, e + m + V, t);
+      } else
+        it(a, i, e, t);
+  }
+  const re = v(), Re = T.value;
+  return Ve = Be(Re, Re.length > 0 && typeof Re[0] != "object" ? null : re.keyField), xe = Ye(Re, re.typeField), re.cache && Ze(re.cache), M.value && re.prerender && (De = true, L(false)), re.gridItems && D(re.itemSize) == null && console.error("[vue-recycle-scroller] You must provide an itemSize when using gridItems"), onMounted(() => {
+    M.value && (Te(), nextTick(() => {
+      De = false, L(true), le.value = true;
+    }));
+  }), onActivated(() => {
+    if (!M.value)
+      return;
+    const e = je;
+    typeof e == "number" && nextTick(() => {
+      Ce(e);
+    });
+  }), onBeforeUnmount(() => {
+    It(), yt(), fe();
+  }), watch(M, (e) => {
+    e ? (Te(), nextTick(() => {
+      L(true), le.value = true;
+    })) : (fe(), It(), yt(), le.value = false);
+  }), watch(() => v().cache, (e) => {
+    M.value && (Ze(e), L(true));
+  }), watch(() => toValue(v().items).slice(), (e, t) => {
+    if (!M.value)
+      return;
+    const r = v(), i = Z.value ? null : r.keyField, a = Be(e, i), d = Ye(e, r.typeField), h = Ve, p = !$n(
+      a,
+      d,
+      h,
+      xe
+    );
+    r.shift && zn(h, a) > 0 ? sn(t ?? [], i) : ne(), Ve = a, xe = d, xt(e), L(p);
+  }), watch(() => v().keyField, () => {
+    if (!M.value)
+      return;
+    const e = v(), t = Z.value ? null : e.keyField;
+    Ve = Be(T.value, t), xe = Ye(T.value, e.typeField), ne(), L(true);
+  }), watch(() => v().typeField, () => {
+    if (!M.value)
+      return;
+    const e = v();
+    xe = Ye(T.value, e.typeField), ne(), L(true);
+  }), watch(ue, () => {
+    M.value && (fe(), Te(), L(false));
+  }), watch(x.el, () => {
+    M.value && (fe(), Te(), L(false));
+  }), watch(ze, () => {
+    !M.value || !ue() || (fe(), Te(), L(false));
+  }), watch(Me, () => {
+    M.value && (xt() && ln(), L(false));
+  }), watch(() => v().gridItems, () => {
+    M.value && L(true);
+  }), watch(() => v().itemSecondarySize, () => {
+    M.value && L(true);
+  }), {
+    pool: N,
+    visiblePool: Dt,
+    totalSize: ge,
+    startSpacerSize: Se,
+    endSpacerSize: ye,
+    ready: le,
+    sizes: Me,
+    simpleArray: Z,
+    scrollToItem: mn,
+    scrollToPosition: Ce,
+    getScroll: de,
+    findItemIndex: wt,
+    getItemOffset: U,
+    getItemSize: Le,
+    getViewStyle: on,
+    cacheSnapshot: Gt,
+    restoreCache: Ze,
+    updateVisibleItems: L,
+    handleResize: Qe,
+    handleVisibilityChange: en,
+    sortViews: Mt
+  };
+}
+export {
+  Ut as a,
+  Be as b,
+  Vn as c,
+  bn as d,
+  Tn as e,
+  zn as f,
+  D as g,
+  Mn as r,
+  qn as u
+};
+//# sourceMappingURL=index250.mjs.map