@vunk/plus 1.14.0 → 1.16.0

package/vue-virtual-scroller/index.mjs

@@ -0,0 +1,2708 @@
+import { computed as E, toValue as R, watch as N, nextTick as tt, ref as Se, onMounted as Xt, onActivated as Fn, onBeforeUnmount as Lt, markRaw as ci, shallowReactive as At, reactive as Yt, provide as Mt, shallowRef as vt, watchEffect as pn, triggerRef as hn, onDeactivated as di, onUnmounted as fi, effectScope as mi, defineComponent as St, openBlock as se, createBlock as Be, resolveDynamicComponent as nt, withCtx as Ue, renderSlot as Re, createElementBlock as Qe, toRef as Zt, withDirectives as Cn, normalizeClass as xt, unref as ee, createCommentVNode as Ne, normalizeStyle as ut, Fragment as Vn, renderList as Pn, mergeProps as $t, toHandlers as vi, createVNode as On, createSlots as pi, normalizeProps as hi, guardReactiveProps as yi, inject as yn, getCurrentInstance as gi, onBeforeUpdate as Si } from "vue";
+function bi(e) {
+  return e == null ? "null" : typeof e == "function" ? "a function" : `'${e}'`;
+}
+function ht(e, t, i) {
+  if (!i)
+    return t;
+  const n = typeof i == "function" ? i(e, t) : e?.[i];
+  if (n == null)
+    throw new Error(`Key is ${n} on item (keyField is ${bi(i)})`);
+  return n;
+}
+function Jt(e, t, i) {
+  if (typeof i == "function" && t == null)
+    throw new Error("index is required when using a function keyField");
+  return ht(e, t ?? 0, i);
+}
+function en(e, t, i) {
+  return ht(e, t, i);
+}
+function et(e, t) {
+  return e.map((i, n) => en(i, n, t));
+}
+function zi(e, t, i) {
+  const n = [], l = [];
+  for (let c = 0; c < e.length; c++) {
+    const p = e[c], v = en(p, c, t), m = i(p, c, v);
+    n.push(v), l.push(typeof m == "number" && m > 0 ? m : null);
+  }
+  return {
+    keys: n,
+    sizes: l
+  };
+}
+function wi(e, t, i) {
+  if (!e || e.keys.length !== t.length || e.sizes.length !== t.length)
+    return !1;
+  for (let n = 0; n < t.length; n++)
+    if (e.keys[n] !== en(t[n], n, i))
+      return !1;
+  return !0;
+}
+function Gt(e, t, i) {
+  if (!wi(e, t, i))
+    return {};
+  const n = {};
+  for (let l = 0; l < e.keys.length; l++) {
+    const c = e.sizes[l];
+    typeof c == "number" && c > 0 && (n[e.keys[l]] = c);
+  }
+  return n;
+}
+function Dn(e, t) {
+  if (!e.length || t.length <= e.length)
+    return 0;
+  const i = e[0], n = t.indexOf(i);
+  if (n <= 0 || n + e.length < t.length && e.length > t.length - n)
+    return 0;
+  for (let l = 0; l < e.length; l++)
+    if (t[n + l] !== e[l])
+      return 0;
+  return n;
+}
+function gn(e, t, i, n, l, c = 0) {
+  const p = l ?? "start";
+  if (p === "nearest") {
+    const v = i + n, m = e + t;
+    return e >= i && m <= v ? null : e < i ? e + c : m - n + c;
+  }
+  return p === "end" ? e + t - n + c : p === "center" ? e + (t - n) / 2 + c : e + c;
+}
+const Ii = /auto|scroll/;
+function Bn(e, t) {
+  return e.parentNode === null ? t : Bn(e.parentNode, [...t, e]);
+}
+function qt(e, t) {
+  return getComputedStyle(e, null).getPropertyValue(t);
+}
+function _i(e) {
+  return qt(e, "overflow") + qt(e, "overflow-y") + qt(e, "overflow-x");
+}
+function Mi(e) {
+  return Ii.test(_i(e));
+}
+function xi(e) {
+  if (!(e instanceof HTMLElement || e instanceof SVGElement))
+    return;
+  if (e.parentNode === null)
+    return document.scrollingElement || document.documentElement;
+  const t = Bn(e.parentNode, []);
+  for (let i = 0; i < t.length; i += 1)
+    if (t[i] instanceof Element && Mi(t[i]))
+      return t[i];
+  return document.scrollingElement || document.documentElement;
+}
+function An(e, t) {
+  if (t)
+    return t;
+  if (!e)
+    return;
+  const i = xi(e);
+  if (i)
+    return typeof window < "u" && window.document && (i === window.document.documentElement || i === window.document.body) ? window : i;
+}
+function Ti() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    on(t, i) {
+      let n = e.get(t);
+      n || (n = /* @__PURE__ */ new Set(), e.set(t, n)), n.add(i);
+    },
+    off(t, i) {
+      const n = e.get(t);
+      n && (n.delete(i), n.size || e.delete(t));
+    },
+    emit(t, i) {
+      const n = e.get(t);
+      if (n?.size)
+        for (const l of [...n])
+          l(i);
+    },
+    clear() {
+      e.clear();
+    }
+  };
+}
+function yt(e) {
+  return e.flowMode && e.direction === "vertical" && !e.gridItems ? "flow" : e.disableTransform ? "position" : "transform";
+}
+function tn(e, t) {
+  const i = t.direction === "vertical", n = t.mode ?? "transform", l = {
+    visibility: e.nr.used ? "visible" : "hidden",
+    pointerEvents: e.nr.used ? void 0 : "none"
+  };
+  if (n === "flow" ? l.display = e.nr.used ? void 0 : "none" : (l.position = "absolute", l.top = "0px", l.left = "0px", l.display = void 0), n === "position" ? (l[i ? "top" : "left"] = `${e.position}px`, l[i ? "left" : "top"] = `${e.offset}px`, l.transform = "none", l.willChange = "unset") : n === "transform" && (l.transform = i ? `translateY(${e.position}px) translateX(${e.offset}px)` : `translateX(${e.position}px) translateY(${e.offset}px)`, l.willChange = "transform"), t.gridItems && t.itemSize != null) {
+    const c = t.itemSecondarySize || t.itemSize;
+    l.width = `${i ? c : t.itemSize}px`, l.height = `${i ? t.itemSize : c}px`;
+  }
+  return l;
+}
+const ki = "[vue-virtual-scroller] `sizeDependencies` is deprecated and will be removed in the next major release. Dynamic item sizing uses ResizeObserver in modern browsers.";
+let Sn = !1;
+function bn(e) {
+  e == null || Sn || (Sn = !0, console.warn(ki));
+}
+function $n(e, t, i, n) {
+  let l = null, c = null, p = null, v = !1, m = null;
+  const g = [], T = i.resizeObserver ? () => {
+  } : i.onVscrollUpdate(B), z = E(() => {
+    const f = R(e);
+    if (i.vscrollData.simpleArray) {
+      if (f.index == null)
+        throw new Error("index is required when using simple-array mode with dynamic item measurement");
+      return f.index;
+    }
+    return Jt(f.item, f.index, i.vscrollData.keyField);
+  }), w = E(() => i.vscrollData.sizes[z.value] || 0), k = E(() => R(e).active && i.vscrollData.active);
+  function I() {
+    k.value ? c !== z.value && (c = z.value, l = null, p = null, ve(z.value)) : l = z.value;
+  }
+  function C() {
+    R(e).watchData && !i.resizeObserver ? m = N(() => R(e).item, () => {
+      P();
+    }, {
+      deep: !0
+    }) : m && (m(), m = null);
+  }
+  function B({ force: f }) {
+    !k.value && f && (p = z.value), (l === z.value || f || !w.value) && I();
+  }
+  function P() {
+    I();
+  }
+  function q(f) {
+    i.undefinedMap[f] && i.undefinedSizeCount.value--, i.undefinedMap[f] = void 0;
+  }
+  function te(f, O) {
+    if (i.vscrollData.sizes[f]) {
+      q(f);
+      return;
+    }
+    if (O) {
+      i.undefinedMap[f] || i.undefinedSizeCount.value++, i.undefinedMap[f] = !0;
+      return;
+    }
+    i.undefinedMap[f] && (i.undefinedSizeCount.value--, i.undefinedMap[f] = !1);
+  }
+  function ve(f) {
+    i.measureQueue.schedule(f, {
+      read() {
+        if (z.value !== f)
+          return null;
+        const O = R(t);
+        return O ? {
+          width: O.offsetWidth,
+          height: O.offsetHeight
+        } : null;
+      },
+      write(O) {
+        const { width: J, height: ne } = O;
+        S(J, ne);
+      },
+      done() {
+        c = null;
+      }
+    });
+  }
+  function S(f, O) {
+    const J = ~~(i.direction.value === "vertical" ? O : f);
+    J && w.value !== J && K(J);
+  }
+  function K(f) {
+    q(z.value), i.vscrollData.sizes[z.value] = f, R(e).emitResize && R(n)?.onResize?.(z.value);
+  }
+  function le() {
+    if (!i.resizeObserver || v)
+      return;
+    const f = R(t);
+    f && (i.resizeObserver.observe(f), f.$_vs_id = z.value, f.$_vs_onResize = Ce, v = !0);
+  }
+  function _e() {
+    if (!i.resizeObserver || !v)
+      return;
+    const f = R(t);
+    f && (i.resizeObserver.unobserve(f), f.$_vs_onResize = void 0, v = !1);
+  }
+  function Ce(f, O, J) {
+    z.value === f && S(O, J);
+  }
+  bn(R(e).sizeDependencies), g.push(N(() => R(e).watchData, () => {
+    C();
+  })), g.push(N(() => R(e).sizeDependencies, (f) => {
+    bn(f), i.resizeObserver || P();
+  }, {
+    deep: !0
+  })), g.push(N(z, (f, O) => {
+    const J = R(t);
+    J && (J.$_vs_id = f), q(O), te(f, k.value);
+    const ne = i.vscrollData.sizes[f];
+    if (!ne) {
+      l = f, P();
+      return;
+    }
+    q(f), v && (i.vscrollData.sizes[f] = ne);
+  })), g.push(N(k, (f) => {
+    te(z.value, f), i.resizeObserver ? f ? le() : _e() : f && p === z.value && I();
+  })), C();
+  function A() {
+    k.value && (I(), le());
+  }
+  function Y() {
+    i.measureQueue.cancel(z.value), T(), _e(), q(z.value);
+    const f = R(t);
+    f && (f.$_vs_id = void 0, f.$_vs_onResize = void 0), m && (m(), m = null);
+    for (const O of g)
+      O();
+    g.length = 0;
+  }
+  return {
+    id: z,
+    size: w,
+    finalActive: k,
+    updateSize: I,
+    mount: A,
+    unmount: Y
+  };
+}
+function Ri(e = {}) {
+  const t = e.queueFlush ?? ((T) => tt(T)), i = e.overflowQueueFlush ?? t, n = Math.max(1, e.maxTasksPerFlush ?? Number.POSITIVE_INFINITY);
+  let l = !1;
+  const c = /* @__PURE__ */ new Map();
+  function p() {
+    l || !c.size || (l = !0, t(v));
+  }
+  function v() {
+    if (l = !1, !c.size)
+      return;
+    const T = [];
+    for (const [w, k] of c)
+      if (T.push(k), c.delete(w), T.length >= n)
+        break;
+    const z = T.map((w) => ({
+      task: w,
+      value: w.read()
+    }));
+    for (const w of z)
+      w.value != null && w.task.write(w.value), w.task.done();
+    c.size && (i(v), l = !0);
+  }
+  function m(T, z) {
+    c.set(T, z), p();
+  }
+  function g(T) {
+    c.delete(T);
+  }
+  return {
+    schedule: m,
+    cancel: g
+  };
+}
+function nn(e) {
+  return E(() => R(e));
+}
+function Ei(e, t, i, n, l) {
+  const c = nn(e);
+  return {
+    el: E(() => {
+      const p = c.value.el;
+      return R(t ?? p);
+    }),
+    before: E(() => {
+      const p = c.value.before;
+      return R(i ?? p);
+    }),
+    after: E(() => {
+      const p = c.value.after;
+      return R(n ?? p);
+    }),
+    scrollParent: E(() => {
+      const p = c.value.scrollParent;
+      return R(p);
+    }),
+    callbacks: {
+      onResize: () => (l?.onResize ?? c.value.onResize)?.(),
+      onVisible: () => (l?.onVisible ?? c.value.onVisible)?.(),
+      onHidden: () => (l?.onHidden ?? c.value.onHidden)?.(),
+      onUpdate: (p, v, m, g) => (l?.onUpdate ?? c.value.onUpdate)?.(p, v, m, g)
+    }
+  };
+}
+const Fi = {
+  itemsLimit: 1e3
+};
+function Ln(e) {
+  return typeof window < "u" && e === window;
+}
+const Ci = (() => {
+  if (typeof document > "u")
+    return "negative";
+  const e = document.createElement("div"), t = document.createElement("div");
+  e.style.width = "4px", e.style.height = "1px", e.style.overflow = "auto", e.style.direction = "rtl", t.style.width = "8px", t.style.height = "1px", e.appendChild(t), document.body.appendChild(e), e.scrollLeft = -1;
+  const i = e.scrollLeft < 0;
+  return document.body.removeChild(e), i ? "negative" : "default";
+})();
+function pt(e, t, i) {
+  return t !== "horizontal" || !i || Ln(i) || getComputedStyle(i).direction !== "rtl" ? e : Ci === "negative" ? -e : e;
+}
+function Vi(e, t, i) {
+  return pt(e, t, i);
+}
+function Kt(e, t, i, n) {
+  const l = Vi(i, t, e), c = !!n?.smooth;
+  if (Ln(e)) {
+    t === "vertical" ? e.scrollTo({
+      top: l,
+      behavior: c ? "smooth" : "auto"
+    }) : e.scrollTo({
+      left: l,
+      behavior: c ? "smooth" : "auto"
+    });
+    return;
+  }
+  if (typeof e.scrollTo == "function") {
+    e.scrollTo(t === "vertical" ? { top: l, behavior: c ? "smooth" : "auto" } : { left: l, behavior: c ? "smooth" : "auto" });
+    return;
+  }
+  t === "vertical" ? e.scrollTop = l : e.scrollLeft = l;
+}
+function Pi(e, t, i, n) {
+  if (i) {
+    if (n && n !== window) {
+      const l = n;
+      return t === "vertical" ? l.clientHeight : l.clientWidth;
+    }
+    return t === "vertical" ? window.innerHeight : window.innerWidth;
+  }
+  return t === "vertical" ? e.clientHeight : e.clientWidth;
+}
+let Qt = !1;
+function Oi() {
+  return Qt;
+}
+if (typeof window < "u") {
+  Qt = !1;
+  try {
+    const e = Object.defineProperty({}, "passive", {
+      get() {
+        Qt = !0;
+      }
+    });
+    window.addEventListener("test", null, e);
+  } catch {
+  }
+}
+function He(e) {
+  return typeof e == "number" ? e : null;
+}
+function Di(e, t, i, n, l) {
+  return typeof i == "number" ? i : typeof i == "function" ? i(e, t) || n || void 0 : n || e?.[l ?? "size"] || void 0;
+}
+function Bi(e, t, i, n, l, c) {
+  return typeof i == "function" ? i(e, t) || n || Number(l) || 0 : n || e?.[c ?? "size"] || Number(l) || 0;
+}
+let Ai = 0;
+const $i = [];
+function Li(e) {
+  for (let t = 0; t < e.length; t++)
+    e[t];
+}
+function Wi(e, t) {
+  return e && typeof e == "object" ? e[t] : void 0;
+}
+function Bt(e, t) {
+  return e.map((i) => Wi(i, t));
+}
+function Hi(e, t, i, n) {
+  if (e.length !== i.length || t.length !== n.length)
+    return !1;
+  for (let l = 0; l < e.length; l++)
+    if (e[l] !== i[l] || t[l] !== n[l])
+      return !1;
+  return !0;
+}
+function Ni(e) {
+  const t = e;
+  t._vs_styleStamp++;
+}
+function zn(e) {
+  const t = e;
+  t._vs_visibilityStamp++, t._vs_styleStamp++;
+}
+function Ui(e, t, i, n) {
+  if (i) {
+    for (const l of i)
+      n(l);
+    return;
+  }
+  for (let l = e; l < t; l++)
+    n(l);
+}
+const wn = 8, In = 1;
+function rn(e, t, i, n, l, c) {
+  const p = nn(e), v = Ei(p, t, i, n, l), m = E(() => {
+    const r = R(F().items);
+    return Li(r), r;
+  }), g = Se([]), T = Se(0), z = Se(0), w = Se(0), k = Se(!1);
+  let I = 0, C = 0, B = 0, P = 0, q = !1, te = null;
+  const ve = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map();
+  let K = !1, le = 0, _e = 0, Ce = !1, A = null, Y = null, f = null, O = 0, J = null, ne = null, je = [], pe = [], Me = null, ie = null, xe = null, Ie = !1, G = !1, Pe = !1;
+  const ae = /* @__PURE__ */ new Set(), Oe = Se({}), ct = [], Tt = {
+    accumulator: 0
+  };
+  function F() {
+    return p.value;
+  }
+  function Ae() {
+    return c?.pageMode ?? F().pageMode;
+  }
+  const $ = E(() => R(F().enabled ?? !0)), it = E(() => An(
+    v.el.value,
+    v.scrollParent.value
+  )), $e = E(() => {
+    const r = m.value;
+    return r.length > 0 && typeof r[0] != "object";
+  }), rt = E(() => {
+    const r = F();
+    if (He(r.itemSize) === null) {
+      const a = m.value, d = Array.from({ length: a.length });
+      Tt.accumulator = 0, d[-1] = Tt;
+      const h = r.minItemSize, x = Oe.value, L = $e.value;
+      let D = 1e4, U = 0, oe;
+      for (let _ = 0, Q = a.length; _ < Q; _++) {
+        const ce = L ? _ : ht(a[_], _, r.keyField);
+        oe = Bi(
+          a[_],
+          _,
+          r.itemSize,
+          x[ce],
+          h,
+          r.sizeField
+        ), oe < D && (D = oe), U += oe;
+        const re = ct[_] ?? (ct[_] = {
+          accumulator: 0,
+          size: void 0
+        });
+        re.accumulator = U, re.size = oe, d[_] = re;
+      }
+      return ct.length = a.length, O = D, d;
+    }
+    return $i;
+  }), kt = E(
+    () => g.value.filter((r) => (r._vs_visibilityStamp, r.nr.used)).sort((r, o) => r.nr.index - o.nr.index)
+  ), bt = E(() => {
+    const r = F(), o = $e.value ? null : r.keyField;
+    return zi(m.value, o, (a, d, h) => Di(
+      a,
+      d,
+      r.itemSize,
+      Oe.value[h],
+      r.sizeField
+    ));
+  });
+  function De(r = F()) {
+    return r.direction ?? "vertical";
+  }
+  function Xe(r = F()) {
+    const o = De(r);
+    let a = r.flowMode ?? !1;
+    return a && o !== "vertical" && (G || (console.warn("[vue-recycle-scroller] flowMode only supports vertical lists. Falling back to standard positioning."), G = !0), a = !1), a && r.gridItems && (Pe || (console.warn("[vue-recycle-scroller] flowMode does not support gridItems. Falling back to standard positioning."), Pe = !0), a = !1), yt({
+      direction: o,
+      disableTransform: r.disableTransform ?? !1,
+      flowMode: a,
+      gridItems: r.gridItems
+    });
+  }
+  function qe() {
+    g.value.sort((r, o) => r.nr.used !== o.nr.used ? r.nr.used ? -1 : 1 : r.nr.used && o.nr.used ? r.nr.index - o.nr.index : r.nr.id - o.nr.id);
+  }
+  function zt(r) {
+    const o = F();
+    return Oe.value = Gt(r, m.value, $e.value ? null : o.keyField), Object.keys(Oe.value).length > 0;
+  }
+  function wt(r) {
+    let o = S.get(r);
+    return o || (o = [], S.set(r, o)), o;
+  }
+  function Wt(r, o, a, d, h) {
+    const x = ci({
+      id: Ai++,
+      index: o,
+      used: !0,
+      key: d,
+      type: h
+    }), L = At({
+      item: a,
+      position: 0,
+      offset: 0,
+      nr: x,
+      _vs_styleStamp: 0,
+      _vs_visibilityStamp: 0
+    });
+    return r.push(L), L;
+  }
+  function Ht(r) {
+    const o = wt(r);
+    if (o && o.length) {
+      const a = o.pop();
+      return a.nr.used = !0, zn(a), a;
+    }
+  }
+  function Ze(r, o) {
+    const a = g.value, d = a.indexOf(r);
+    if (d === -1)
+      return;
+    const h = Math.max(0, Math.min(o, a.length - 1));
+    d !== h && (a.splice(d, 1), a.splice(h, 0, r));
+  }
+  function s(r) {
+    Ze(r, g.value.length - 1);
+  }
+  function u() {
+    const r = g.value;
+    let o = 0;
+    for (; o < r.length && !r[o].nr.used; )
+      o++;
+    let a = 0;
+    for (let d = o; d < r.length && r[d].nr.used; d++)
+      a++;
+    return {
+      activeStart: o,
+      activeCount: a,
+      headInsertCount: 0
+    };
+  }
+  function y(r, o, a) {
+    let d = null;
+    o < I ? (d = a.activeStart + a.headInsertCount, a.headInsertCount++, a.activeCount++) : o >= C && (d = a.activeStart + a.activeCount, a.activeCount++), d != null && Ze(r, d);
+  }
+  function b(r, o = !1) {
+    const a = r.nr.type;
+    wt(a).push(r), r.nr.used = !1, r.position = F().hiddenPosition ?? -999999, zn(r), ve.delete(r.nr.key), o && s(r);
+  }
+  function M() {
+    ve.clear(), S.clear();
+    for (let r = 0, o = g.value.length; r < o; r++) {
+      const a = g.value[r];
+      a && b(a);
+    }
+  }
+  function V(r) {
+    let o = -1;
+    return o = requestAnimationFrame(() => {
+      ae.delete(o), r();
+    }), ae.add(o), o;
+  }
+  function H() {
+    for (const r of ae)
+      cancelAnimationFrame(r);
+    ae.clear();
+  }
+  function ye() {
+    A && (clearTimeout(A), A = null), Y && (clearTimeout(Y), Y = null), f && (clearTimeout(f), f = null), ie && (clearTimeout(ie), ie = null), xe && (clearTimeout(xe), xe = null);
+  }
+  function ue() {
+    $.value && (v.callbacks.onResize?.(), k.value && he(!1));
+  }
+  function Te() {
+    if (!$.value)
+      return;
+    Me && !Ie && lt();
+    const r = F();
+    if (!K) {
+      if (K = !0, A)
+        return;
+      const o = () => V(() => {
+        K = !1;
+        const { continuous: a } = he(!1, !0);
+        a || (Y && clearTimeout(Y), Y = setTimeout(Te, r.updateInterval + 100));
+      });
+      o(), r.updateInterval && (A = setTimeout(() => {
+        A = null, K && o();
+      }, r.updateInterval));
+    }
+  }
+  function Ve(r, o) {
+    $.value && k.value && (r || o.boundingClientRect.width !== 0 || o.boundingClientRect.height !== 0 ? (v.callbacks.onVisible?.(), V(() => {
+      he(!1);
+    })) : v.callbacks.onHidden?.());
+  }
+  function Le() {
+    return it.value ?? window;
+  }
+  function Ee() {
+    const r = v.before.value;
+    if (!r)
+      return 0;
+    const o = F();
+    return De(o) === "vertical" ? r.scrollHeight : r.scrollWidth;
+  }
+  function be() {
+    const r = v.el.value;
+    if (!r)
+      return { start: 0, end: 0 };
+    const o = F(), a = De(o), d = a === "vertical";
+    let h;
+    if (Ae()) {
+      const x = r.getBoundingClientRect(), L = d ? x.height : x.width, D = it.value, U = !D || D === window, oe = U ? 0 : D.getBoundingClientRect().top, _ = U ? 0 : D.getBoundingClientRect().left, Q = U ? window.innerHeight : D.clientHeight, ce = U ? window.innerWidth : D.clientWidth;
+      let re = d ? -(x.top - oe) : -(x.left - _), ze = d ? Q : ce;
+      re < 0 && (ze += re, re = 0), re + ze > L && (ze = L - re), h = {
+        start: re,
+        end: re + ze
+      };
+    } else d ? h = {
+      start: r.scrollTop,
+      end: r.scrollTop + r.clientHeight
+    } : h = {
+      start: pt(r.scrollLeft, a, r),
+      end: pt(r.scrollLeft, a, r) + r.clientWidth
+    };
+    return h;
+  }
+  function Qn() {
+    const r = v.el.value;
+    if (!r)
+      return { start: 0, end: 0 };
+    const o = F();
+    if (De(o) === "vertical") {
+      const a = pt(r.scrollLeft, "horizontal", r);
+      return {
+        start: a,
+        end: a + r.clientWidth
+      };
+    }
+    return {
+      start: r.scrollTop,
+      end: r.scrollTop + r.clientHeight
+    };
+  }
+  function Xn(r, o, a, d) {
+    const h = Ee(), x = r.start - d - h, L = r.end + d - h;
+    if (I > 0) {
+      const D = a[I - 1]?.accumulator ?? 0;
+      if (x <= D)
+        return !0;
+    }
+    if (I < o - 1) {
+      const D = a[I]?.accumulator ?? Number.POSITIVE_INFINITY;
+      if (x > D)
+        return !0;
+    }
+    if (C > 1) {
+      const D = a[C - 2]?.accumulator ?? 0;
+      if (L <= D)
+        return !0;
+    }
+    if (C < o) {
+      const D = a[C - 1]?.accumulator ?? Number.POSITIVE_INFINITY;
+      if (L > D)
+        return !0;
+    }
+    return !1;
+  }
+  function Rt(r) {
+    const o = F(), a = He(o.itemSize);
+    return a !== null ? a : rt.value[r]?.size || Number(o.minItemSize) || 0;
+  }
+  function Zn(r) {
+    const o = F();
+    return tn(r, {
+      direction: De(o),
+      mode: Xe(o),
+      itemSize: He(o.itemSize),
+      gridItems: o.gridItems,
+      itemSecondarySize: o.itemSecondarySize
+    });
+  }
+  function Ke(r) {
+    const o = F(), a = o.gridItems || 1, d = He(o.itemSize);
+    return r <= 0 ? 0 : d !== null ? Math.floor(r / a) * d : rt.value[r - 1]?.accumulator || 0;
+  }
+  function on(r) {
+    const o = F(), a = m.value.length, d = o.gridItems || 1, h = He(o.itemSize);
+    if (!a)
+      return 0;
+    if (h !== null) {
+      const U = Math.floor(r / h) * d;
+      return Math.min(Math.max(U, 0), a - 1);
+    }
+    let x = 0, L = a - 1, D = 0;
+    for (; x <= L; ) {
+      const U = Math.floor((x + L) / 2);
+      Ke(U) <= r ? (D = U, x = U + 1) : L = U - 1;
+    }
+    return D;
+  }
+  function lt() {
+    ie && (clearTimeout(ie), ie = null), Me = null;
+  }
+  function Jn() {
+    ie && clearTimeout(ie), ie = setTimeout(() => {
+      Me = null, ie = null;
+    }, 150);
+  }
+  function ei(r, o) {
+    if (!r.length) {
+      lt();
+      return;
+    }
+    const a = Math.max(be().start - Ee(), 0), d = Math.min(on(a), r.length - 1), h = r[d], x = o ? ht(h, d, o) : d, L = Ee() + Ke(d);
+    Me = {
+      key: x,
+      offset: be().start - L
+    };
+  }
+  function sn(r) {
+    if (!Me)
+      return !1;
+    const o = F(), a = r ?? m.value, d = $e.value ? null : o.keyField, x = et(a, d).indexOf(Me.key);
+    if (x === -1)
+      return lt(), !1;
+    const L = Ee() + Ke(x) + Me.offset, D = be().start;
+    return Math.abs(L - D) < 0.5 ? !1 : (Ie = !0, Et(L), V(() => {
+      Ie = !1;
+    }), !0);
+  }
+  function It() {
+    if (dt(), !$.value)
+      return;
+    const r = Ae() ? Le() : v.el.value;
+    r && (J = r, J.addEventListener("scroll", Te, Oi() ? { passive: !0 } : !1), Ae() && r === window && (ne = r, ne.addEventListener("resize", ue)));
+  }
+  function dt() {
+    J && (J.removeEventListener("scroll", Te), J = null), ne && (ne.removeEventListener("resize", ue), ne = null);
+  }
+  function ti(r, o, a, d, h, x) {
+    const L = Math.ceil(r / o) * a, D = Math.max(0, Math.floor(h.start / a)), U = Math.min(Math.ceil(h.end / a), Math.ceil(r / o)), oe = Math.max(0, Math.floor(x.start / d)), _ = Math.min(Math.ceil(x.end / d), o), Q = [];
+    for (let ze = D; ze < U; ze++) {
+      const ft = ze * o;
+      for (let X = oe; X < _; X++) {
+        const W = ft + X;
+        if (W >= r)
+          break;
+        Q.push(W);
+      }
+    }
+    const ce = Q[0] ?? 0, re = Q.at(-1) ?? -1;
+    return {
+      renderedIndices: Q,
+      startIndex: ce,
+      endIndex: re + 1,
+      visibleStartIndex: ce,
+      visibleEndIndex: re,
+      totalSize: L
+    };
+  }
+  function ni() {
+    const r = F(), o = He(r.itemSize);
+    if (!r.gridItems || o == null)
+      return !1;
+    const a = v.el.value;
+    if (!a)
+      return !1;
+    const d = r.itemSecondarySize || o, h = De(r) === "vertical" ? a.clientWidth : a.clientHeight;
+    return d * r.gridItems > h;
+  }
+  function an(r, o, a, d) {
+    if (Math.abs(r - o) !== 1 || o < 0 || o >= a)
+      return r;
+    const h = r > o ? Ke(o) + Rt(o) : Ke(o);
+    return Math.abs(h - d) <= wn ? o : r;
+  }
+  function un(r, o, a, d, h) {
+    if (Math.abs(r - o) !== 1)
+      return r;
+    const x = h ? o - 1 : o;
+    if (x < 0 || x >= a)
+      return r;
+    const L = r > o ? Ke(x) + Rt(x) : Ke(x);
+    return Math.abs(L - d) <= wn ? o : r;
+  }
+  function ii(r, o, a) {
+    const d = {
+      ...r,
+      visibleStartIndex: an(r.visibleStartIndex, B, o, a.rawViewportStart),
+      visibleEndIndex: un(r.visibleEndIndex, P, o, a.rawViewportEnd, !1),
+      startIndex: an(r.startIndex, I, o, a.renderStart),
+      endIndex: un(r.endIndex, C, o, a.renderEnd, !0)
+    };
+    d.startIndex > d.visibleStartIndex && (d.startIndex = d.visibleStartIndex);
+    const h = Math.min(o, d.visibleEndIndex + 1);
+    return d.endIndex < h && (d.endIndex = h), d.endIndex < d.startIndex && (d.endIndex = d.startIndex), d;
+  }
+  function he(r, o = !1) {
+    if (!$.value)
+      return { continuous: !0 };
+    const a = F(), d = He(a.itemSize), h = a.gridItems || 1, x = a.itemSecondarySize || d || 0, L = O, D = a.typeField, U = $e.value ? null : a.keyField, oe = m.value, _ = oe.length, Q = rt.value, ce = ve, re = g.value;
+    let ze = null, ft = null, X, W, Fe, de, fe;
+    const si = d !== null || _ === 0 || Q[_ - 1] != null;
+    if (!_ || !si)
+      !_ || !te ? X = W = de = fe = Fe = 0 : (X = Math.min(te.startIndex, _), W = Math.min(te.endIndex, _), de = Math.min(te.visibleStartIndex, _), fe = Math.min(te.visibleEndIndex, _), Fe = Q[_ - 1]?.accumulator ?? te.totalSizeValue);
+    else if (Ce)
+      X = de = 0, W = fe = Math.min(a.prerender, oe.length), Fe = 0;
+    else {
+      const Z = be(), we = Qn(), Ye = le, Ge = _e, ge = { ...Z }, _t = { ...we };
+      if (o) {
+        let me = Z.start - Ye;
+        me < 0 && (me = -me);
+        let at = we.start - Ge;
+        at < 0 && (at = -at);
+        const Pt = d === null && Xn(Z, _, Q, a.buffer), ke = d === null && (me >= L || Pt) || d !== null && me >= d, Ot = h > 1 && d != null && at >= x;
+        if (!ke && !Ot)
+          return {
+            continuous: !0
+          };
+      }
+      le = Z.start, _e = we.start;
+      const mt = a.buffer;
+      ge.start -= mt, ge.end += mt, _t.start -= mt, _t.end += mt;
+      let We = 0;
+      const mn = v.before.value;
+      mn && (We = mn.scrollHeight, ge.start -= We);
+      const vn = v.after.value;
+      if (vn) {
+        const me = vn.scrollHeight;
+        ge.end += me;
+      }
+      const ui = Xe(a) === "flow" && d === null && !o && q && Math.abs(Z.start - Ye) <= In && Math.abs(we.start - Ge) <= In;
+      if (d === null) {
+        let me, at = 0, Pt = _ - 1, ke = ~~(_ / 2), Ot;
+        do
+          Ot = ke, me = Q[ke]?.accumulator ?? 0, me < ge.start ? at = ke : ke < _ - 1 && (Q[ke + 1]?.accumulator ?? Number.POSITIVE_INFINITY) > ge.start && (Pt = ke), ke = ~~((at + Pt) / 2);
+        while (ke !== Ot);
+        for (ke < 0 && (ke = 0), X = ke, Fe = Q[_ - 1]?.accumulator ?? 0, W = ke; W < _ && (Q[W]?.accumulator ?? 0) < ge.end; W++) ;
+        for (W === -1 ? W = oe.length - 1 : (W++, W > _ && (W = _)), de = X; de < _ && We + (Q[de]?.accumulator ?? Number.POSITIVE_INFINITY) < ge.start; de++) ;
+        for (fe = de; fe < _ && We + (Q[fe]?.accumulator ?? 0) < ge.end; fe++) ;
+        if (ui) {
+          const Dt = ii({
+            startIndex: X,
+            endIndex: W,
+            visibleStartIndex: de,
+            visibleEndIndex: fe
+          }, _, {
+            rawViewportStart: Z.start - We,
+            rawViewportEnd: Z.end - We,
+            renderStart: Z.start - mt - We,
+            renderEnd: Z.end + mt - We
+          });
+          X = Dt.startIndex, W = Dt.endIndex, de = Dt.visibleStartIndex, fe = Dt.visibleEndIndex;
+        }
+        te = {
+          startIndex: X,
+          endIndex: W,
+          visibleStartIndex: de,
+          visibleEndIndex: fe,
+          totalSizeValue: Fe
+        };
+      } else if (h > 1) {
+        const me = ti(
+          _,
+          h,
+          d,
+          x,
+          ge,
+          _t
+        );
+        ze = me.renderedIndices, ft = new Set(ze), X = me.startIndex, W = me.endIndex, de = me.visibleStartIndex, fe = me.visibleEndIndex, Fe = me.totalSize;
+      } else {
+        X = ~~(ge.start / d * h);
+        const me = X % h;
+        X -= me, W = Math.ceil(ge.end / d * h), de = Math.max(0, Math.floor((ge.start - We) / d * h)), fe = Math.floor((ge.end - We) / d * h), X < 0 && (X = 0), W > _ && (W = _), de < 0 && (de = 0), fe > _ && (fe = _), Fe = Math.ceil(_ / h) * d;
+      }
+    }
+    const ai = typeof a.itemsLimit == "number" && a.itemsLimit > 0 ? a.itemsLimit : Fi.itemsLimit;
+    (ze?.length ?? W - X) > ai && ri(), T.value = Fe, z.value = 0, w.value = Xe(a) === "flow" ? Fe : 0;
+    let j;
+    const Nt = X <= C && W >= I, dn = Xe(a) === "flow", Ut = dn && Nt && !r;
+    let jt = null;
+    if (!Nt || r)
+      M();
+    else {
+      const Z = (we) => {
+        const Ye = re[we];
+        Ye && (j = Ye, j.nr.used && ((ft ? ft.has(j.nr.index) : j.nr.index >= X && j.nr.index < W) || b(j, Ut)));
+      };
+      if (Ut) {
+        for (let we = re.length - 1; we >= 0; we--)
+          Z(we);
+        jt = u();
+      } else
+        for (let we = 0, Ye = re.length; we < Ye; we++)
+          Z(we);
+    }
+    let st, Ct, Vt = null, fn = 0;
+    return Ui(X, W, ze, (Z) => {
+      const we = Q[Z] && Q[Z].size, Ye = d || we || O || 1;
+      st = oe[Z];
+      const Ge = U ? ht(st, Z, U) : Z;
+      j = ce.get(Ge);
+      let ge = !1;
+      if (j)
+        j.item !== st && (j.item = st), j.nr.used || console.warn(`Expected existing view's used flag to be true, got ${j.nr.used}`);
+      else {
+        if (Ct = st[D], j = Ht(Ct), j) {
+          const _t = j.nr.index !== Z || j.nr.key !== Ge;
+          j.item = st, j.nr.index = Z, j.nr.key = Ge, j.nr.type !== Ct && console.warn("Reused view's type does not match pool's type"), _t && Ni(j);
+        } else
+          j = Wt(re, Z, st, Ge, Ct);
+        ce.set(Ge, j), ge = !0;
+      }
+      d === null ? (j.position = Q[Z - 1]?.accumulator || 0, j.offset = 0) : (j.position = Math.floor(Z / h) * d, j.offset = Z % h * x), jt && ge && y(j, Z, jt), Vt ??= j.position, fn += Ye;
+    }), dn ? (Vt == null ? (z.value = 0, w.value = Fe) : (z.value = Vt, w.value = Math.max(0, Fe - Vt - fn)), Ut || qe()) : (z.value = 0, w.value = 0), I = X, C = W, B = de, P = fe, q = !0, a.emitUpdate && v.callbacks.onUpdate?.(X, W, de, fe), Xe(a) !== "flow" && (f && clearTimeout(f), f = setTimeout(cn, a.updateInterval + 300)), {
+      continuous: Nt
+    };
+  }
+  function ri() {
+    throw xe = setTimeout(() => {
+      xe = null, console.warn("It seems the scroller element isn't scrolling, so it tries to render all the items at once.", "Scroller:", v.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 li() {
+    if (ni())
+      return !1;
+    const r = g.value.filter(({ nr: o }) => o.used);
+    for (let o = 1; o < r.length; o++)
+      if (r[o].nr.index !== r[o - 1].nr.index + 1)
+        return !0;
+    return !1;
+  }
+  function cn() {
+    if ($.value) {
+      if (Xe() === "flow") {
+        qe();
+        return;
+      }
+      g.value.sort((r, o) => r.nr.index - o.nr.index), li() && (he(!1), f && clearTimeout(f));
+    }
+  }
+  function oi(r, o) {
+    if (!$.value)
+      return;
+    const a = F(), d = De(a), h = v.el.value;
+    if (!h)
+      return;
+    const x = Math.max(0, Math.min(r, m.value.length - 1)), L = be().start, D = Pi(h, d, a.pageMode, it.value), U = Ke(x), oe = Rt(x), _ = gn(
+      U,
+      oe,
+      L,
+      D,
+      o?.align,
+      o?.offset ?? 0
+    );
+    if (_ == null)
+      return;
+    Et(_, o);
+    const Q = He(a.itemSize);
+    if (a.gridItems && Q != null) {
+      const ce = v.el.value;
+      if (!ce)
+        return;
+      const re = a.gridItems, ze = a.itemSecondarySize || Q, X = x % re * ze, W = d === "vertical" ? "horizontal" : "vertical", Fe = W === "horizontal" ? pt(ce.scrollLeft, "horizontal", ce) : ce.scrollTop, de = W === "horizontal" ? ce.clientWidth : ce.clientHeight, fe = gn(
+        X,
+        ze,
+        Fe,
+        de,
+        o?.align,
+        o?.offset ?? 0
+      );
+      fe != null && Kt(ce, W, fe, o);
+    }
+  }
+  function Et(r, o) {
+    if (!$.value)
+      return;
+    const a = F(), d = De(a), h = v.el.value;
+    if (h)
+      if (Ae()) {
+        const x = it.value ?? window, L = d === "vertical" ? "top" : "left", D = x === window, U = D ? document.scrollingElement || document.documentElement : x, oe = U.getBoundingClientRect(), _ = h.getBoundingClientRect(), Q = D ? d === "vertical" ? window.scrollY : window.scrollX : pt(
+          d === "vertical" ? U.scrollTop : U.scrollLeft,
+          d,
+          U
+        ), ce = _[L] - oe[L];
+        Kt(D ? window : U, d, r + Q + ce, o);
+      } else
+        Kt(h, d, r, o);
+  }
+  const ot = F(), Ft = m.value;
+  return je = et(Ft, Ft.length > 0 && typeof Ft[0] != "object" ? null : ot.keyField), pe = Bt(Ft, ot.typeField), ot.cache && zt(ot.cache), $.value && ot.prerender && (Ce = !0, he(!1)), ot.gridItems && He(ot.itemSize) == null && console.error("[vue-recycle-scroller] You must provide an itemSize when using gridItems"), Xt(() => {
+    $.value && (It(), tt(() => {
+      Ce = !1, he(!0), k.value = !0;
+    }));
+  }), Fn(() => {
+    if (!$.value)
+      return;
+    const r = le;
+    typeof r == "number" && tt(() => {
+      Et(r);
+    });
+  }), Lt(() => {
+    ye(), H(), dt();
+  }), N($, (r) => {
+    r ? (It(), tt(() => {
+      he(!0), k.value = !0;
+    })) : (dt(), ye(), H(), k.value = !1);
+  }), N(() => F().cache, (r) => {
+    $.value && (zt(r), he(!0));
+  }), N(() => R(F().items).slice(), (r, o) => {
+    if (!$.value)
+      return;
+    const a = F(), d = $e.value ? null : a.keyField, h = et(r, d), x = Bt(r, a.typeField), L = je, U = !Hi(
+      h,
+      x,
+      L,
+      pe
+    );
+    a.shift && Dn(L, h) > 0 ? ei(o ?? [], d) : lt(), je = h, pe = x, sn(r), he(U);
+  }), N(() => F().keyField, () => {
+    if (!$.value)
+      return;
+    const r = F(), o = $e.value ? null : r.keyField;
+    je = et(m.value, o), pe = Bt(m.value, r.typeField), lt(), he(!0);
+  }), N(() => F().typeField, () => {
+    if (!$.value)
+      return;
+    const r = F();
+    pe = Bt(m.value, r.typeField), lt(), he(!0);
+  }), N(Ae, () => {
+    $.value && (dt(), It(), he(!1));
+  }), N(v.el, () => {
+    $.value && (dt(), It(), he(!1));
+  }), N(it, () => {
+    !$.value || !Ae() || (dt(), It(), he(!1));
+  }), N(rt, () => {
+    $.value && (sn() && Jn(), he(!1));
+  }), N(() => F().gridItems, () => {
+    $.value && he(!0);
+  }), N(() => F().itemSecondarySize, () => {
+    $.value && he(!0);
+  }), {
+    pool: g,
+    visiblePool: kt,
+    totalSize: T,
+    startSpacerSize: z,
+    endSpacerSize: w,
+    ready: k,
+    sizes: rt,
+    simpleArray: $e,
+    scrollToItem: oi,
+    scrollToPosition: Et,
+    getScroll: be,
+    findItemIndex: on,
+    getItemOffset: Ke,
+    getItemSize: Rt,
+    getViewStyle: Zn,
+    cacheSnapshot: bt,
+    restoreCache: zt,
+    updateVisibleItems: he,
+    handleResize: ue,
+    handleVisibilityChange: Ve,
+    sortViews: cn
+  };
+}
+function ji(e) {
+  for (let t = 0; t < e.length; t++)
+    e[t];
+}
+function Wn(e) {
+  return e.item;
+}
+function gt(e, t) {
+  const i = t.get(e);
+  return i || e;
+}
+function qi(e) {
+  const t = {};
+  return Object.defineProperties(t, {
+    item: {
+      enumerable: !0,
+      get: () => e.item.item
+    },
+    itemWithSize: {
+      enumerable: !0,
+      get: () => e.item
+    },
+    size: {
+      enumerable: !0,
+      get: () => e.item.size
+    },
+    position: {
+      enumerable: !0,
+      get: () => e.position
+    },
+    offset: {
+      enumerable: !0,
+      get: () => e.offset
+    },
+    id: {
+      enumerable: !0,
+      get: () => e.nr.id
+    },
+    index: {
+      enumerable: !0,
+      get: () => e.nr.index
+    },
+    used: {
+      enumerable: !0,
+      get: () => e.nr.used
+    },
+    key: {
+      enumerable: !0,
+      get: () => e.nr.key
+    },
+    type: {
+      enumerable: !0,
+      get: () => e.nr.type
+    }
+  }), t;
+}
+function Ki(e) {
+  return e._vs_styleStamp ?? 0;
+}
+function Yi(e) {
+  return e._vs_visibilityStamp ?? 0;
+}
+const Hn = [
+  "position",
+  "top",
+  "left",
+  "transform",
+  "willChange",
+  "visibility",
+  "pointerEvents",
+  "display"
+];
+function _n(e) {
+  const t = {};
+  for (const i of Hn)
+    t[i] = e.style[i];
+  return t;
+}
+function Nn(e, t) {
+  for (const i of Hn)
+    e.style[i] = t[i] ?? "";
+}
+function Je(e, t, i) {
+  e.style[t] !== i && (e.style[t] = i);
+}
+function Mn(e, t, i, n, l, c, p) {
+  if (!("view" in t)) {
+    Nn(e, c);
+    return;
+  }
+  const v = e.tagName === "TR", m = yt(l ? {
+    direction: i,
+    flowMode: !0
+  } : {
+    direction: i,
+    disableTransform: n || v
+  }), g = tn(gt(t.view, p), {
+    direction: i,
+    mode: m
+  });
+  Je(e, "position", String(g.position ?? "")), Je(e, "top", String(g.top ?? "")), Je(e, "left", String(g.left ?? "")), Je(e, "transform", m === "flow" || v ? "" : String(g.transform ?? "")), Je(e, "willChange", String(g.willChange ?? "")), Je(e, "visibility", String(g.visibility ?? "")), Je(e, "pointerEvents", String(g.pointerEvents ?? "")), Je(e, "display", String(g.display ?? ""));
+}
+function xn(e, t) {
+  return "view" in e && !t;
+}
+function Tn(e, t, i, n, l, c) {
+  if ("view" in e) {
+    const p = gt(e.view, c);
+    return {
+      active: p.nr.used && l,
+      id: Wn(p).id
+    };
+  }
+  return {
+    active: t.active && l,
+    id: Zi(
+      t.item,
+      i,
+      n,
+      t.index
+    )
+  };
+}
+function Gi(e, t, i, n) {
+  if (!("view" in e))
+    return {
+      direction: t,
+      flowMode: i,
+      legacy: !0
+    };
+  if (i) {
+    const c = gt(e.view, n);
+    return {
+      direction: t,
+      flowMode: i,
+      legacy: !1,
+      visibilityStamp: Yi(c)
+    };
+  }
+  const l = gt(e.view, n);
+  return {
+    active: l.nr.used,
+    direction: t,
+    flowMode: i,
+    legacy: !1,
+    styleStamp: Ki(l),
+    position: xn(e, i) ? l.position : null,
+    offset: xn(e, i) ? l.offset : null
+  };
+}
+function kn(e, t) {
+  if ("view" in e) {
+    const i = gt(e.view, t);
+    return {
+      item: Wn(i).item,
+      active: i.nr.used,
+      index: i.nr.index,
+      watchData: e.watchData ?? !1,
+      emitResize: e.emitResize ?? !1,
+      sizeDependencies: e.sizeDependencies ?? null,
+      onResize: e.onResize
+    };
+  }
+  return {
+    watchData: !1,
+    emitResize: !1,
+    sizeDependencies: null,
+    ...e
+  };
+}
+function Qi(e, t) {
+  e.item !== t.item && (e.item = t.item), e.active !== t.active && (e.active = t.active), e.index !== t.index && (e.index = t.index), e.watchData !== t.watchData && (e.watchData = t.watchData), e.sizeDependencies !== t.sizeDependencies && (e.sizeDependencies = t.sizeDependencies), e.emitResize !== t.emitResize && (e.emitResize = t.emitResize), e.onResize !== t.onResize && (e.onResize = t.onResize);
+}
+function Xi(e, t) {
+  e.onResize !== t.onResize && (e.onResize = t.onResize);
+}
+function Zi(e, t, i, n) {
+  return i ? n ?? null : Jt(e, n, t);
+}
+function Ji(e) {
+  const t = nn(e);
+  let i = 0, n = {};
+  const l = Ti();
+  let c = !1, p, v = !1, m = [], g = null, T = null, z = null;
+  const w = /* @__PURE__ */ new Set(), k = [], I = Yt({
+    active: !0,
+    sizes: {},
+    keyField: S().keyField,
+    simpleArray: !1
+  }), C = E(() => {
+    const s = R(S().items);
+    return ji(s), s;
+  }), B = E(() => S().direction ?? "vertical"), P = E(() => R(S().el)), q = E(() => R(S().before)), te = E(() => R(S().after)), ve = /* @__PURE__ */ new Map();
+  function S() {
+    return t.value;
+  }
+  const K = E(() => R(S().enabled ?? !0));
+  function le(s) {
+    let u = -1;
+    return u = requestAnimationFrame(() => {
+      w.delete(u), s();
+    }), w.add(u), u;
+  }
+  function _e() {
+    for (const s of w)
+      cancelAnimationFrame(s);
+    w.clear();
+  }
+  const Ce = Ri({
+    // Spread row measurement across frames so one huge flush cannot monopolize layout time.
+    maxTasksPerFlush: 6,
+    overflowQueueFlush(s) {
+      le(s);
+    }
+  });
+  typeof ResizeObserver < "u" && (p = new ResizeObserver((s) => {
+    le(() => {
+      if (Array.isArray(s)) {
+        for (const u of s)
+          if (u.target && u.target.$_vs_onResize) {
+            let y, b;
+            if (u.borderBoxSize) {
+              const M = u.borderBoxSize[0];
+              y = M.inlineSize, b = M.blockSize;
+            } else
+              y = u.contentRect.width, b = u.contentRect.height;
+            u.target.$_vs_onResize(u.target.$_vs_id, y, b);
+          }
+      }
+    });
+  }));
+  const A = {
+    vscrollData: I,
+    resizeObserver: p,
+    measureQueue: Ce,
+    direction: B,
+    undefinedMap: n,
+    undefinedSizeCount: {
+      get value() {
+        return i;
+      },
+      set value(s) {
+        i = s;
+      }
+    },
+    onVscrollUpdate(s) {
+      const u = (y) => {
+        s(y);
+      };
+      return l.on("vscroll:update", u), () => l.off("vscroll:update", u);
+    }
+  };
+  Mt("vscrollData", I), Mt("vscrollParent", {
+    get $_undefinedSizes() {
+      return i;
+    },
+    set $_undefinedSizes(s) {
+      i = s;
+    },
+    get $_undefinedMap() {
+      return n;
+    },
+    set $_undefinedMap(s) {
+      n = s;
+    },
+    $_events: l,
+    direction: B
+  }), Mt("vscrollResizeObserver", p), Mt("vscrollMeasurementContext", A), Mt("vscrollAnchorRegistry", {
+    delete(s) {
+      ve.delete(s);
+    },
+    set(s, u) {
+      ve.set(s, u);
+    }
+  });
+  const Y = E(() => {
+    const s = C.value;
+    return s.length > 0 && typeof s[0] != "object";
+  }), f = vt(0), O = vt(k);
+  pn(() => {
+    if (!K.value)
+      return;
+    const s = T || !P.value ? null : J(P.value.scrollTop, k), y = S().keyField, b = Y.value, M = I.sizes, V = C.value, H = V.length;
+    let ye = k.length !== H, ue = k.length !== H;
+    for (let Te = 0; Te < H; Te++) {
+      const Ve = V[Te], Le = b ? Te : ht(Ve, Te, y);
+      let Ee = M[Le];
+      typeof Ee > "u" && !n[Le] && (Ee = 0);
+      let be = k[Te];
+      if (!be) {
+        be = At({
+          item: Ve,
+          id: Le,
+          size: Ee
+        }), k[Te] = be, ye = !0, ue = !0;
+        continue;
+      }
+      be.item !== Ve && (be.item = Ve, ye = !0, ue = !0), be.id !== Le && (be.id = Le, ye = !0, ue = !0), be.size !== Ee && (be.size = Ee, ye = !0);
+    }
+    k.length !== H && (k.length = H, ye = !0, ue = !0), ye && (g = s, f.value++, ue ? O.value = k.slice() : hn(O));
+  });
+  function J(s, u) {
+    if (!u.length)
+      return null;
+    const y = S().minItemSize;
+    let b = 0, M = 0, V = u[0].id;
+    for (const H of u) {
+      const ye = H.size || y, ue = b + ye;
+      if (M = b, V = H.id, s < ue)
+        return {
+          key: H.id,
+          offset: s - b
+        };
+      b = ue;
+    }
+    return {
+      key: V,
+      offset: Math.max(0, s - M)
+    };
+  }
+  const ne = S();
+  m = et(C.value, Y.value ? null : ne.keyField), ne.cache && (I.sizes = Gt(ne.cache, C.value, Y.value ? null : ne.keyField));
+  function je() {
+    S().onHidden?.();
+  }
+  function pe(s, u, y, b) {
+    S().onUpdate?.(s, u, y, b);
+  }
+  const Me = Yt({
+    get enabled() {
+      return K.value;
+    },
+    get items() {
+      return O.value;
+    },
+    get keyField() {
+      return "id";
+    },
+    get direction() {
+      return B.value;
+    },
+    get itemSize() {
+      return null;
+    },
+    get gridItems() {
+    },
+    get itemSecondarySize() {
+    },
+    get minItemSize() {
+      return S().minItemSize;
+    },
+    get sizeField() {
+      return "size";
+    },
+    get typeField() {
+      return "type";
+    },
+    get buffer() {
+      return S().buffer ?? 200;
+    },
+    get pageMode() {
+      return S().pageMode ?? !1;
+    },
+    get shift() {
+      return !1;
+    },
+    get cache() {
+      return S().cache;
+    },
+    get prerender() {
+      return S().prerender ?? 0;
+    },
+    get emitUpdate() {
+      return S().emitUpdate ?? !1;
+    },
+    get disableTransform() {
+      return S().disableTransform ?? !1;
+    },
+    get flowMode() {
+      return S().flowMode ?? !1;
+    },
+    get hiddenPosition() {
+      return S().hiddenPosition;
+    },
+    get updateInterval() {
+      return S().updateInterval ?? 0;
+    },
+    get el() {
+      return P.value;
+    },
+    get before() {
+      return q.value;
+    },
+    get after() {
+      return te.value;
+    },
+    get scrollParent() {
+      return S().scrollParent;
+    },
+    get onResize() {
+      return ie;
+    },
+    get onVisible() {
+      return xe;
+    },
+    get onHidden() {
+      return je;
+    },
+    get onUpdate() {
+      return pe;
+    }
+  });
+  function ie() {
+    qe(), S().onResize?.();
+  }
+  function xe() {
+    l.emit("vscroll:update", { force: !1 }), S().onVisible?.();
+  }
+  const Ie = rn(
+    Me
+  ), G = /* @__PURE__ */ new WeakMap(), Pe = /* @__PURE__ */ new WeakMap(), ae = vt([]);
+  function Oe(s) {
+    const u = S();
+    return tn(gt(s, G), {
+      direction: B.value,
+      mode: yt({
+        direction: B.value,
+        disableTransform: u.disableTransform ?? !1,
+        flowMode: u.flowMode ?? !1
+      })
+    });
+  }
+  function ct(s) {
+    let u = Pe.get(s);
+    return u || (u = qi(s), Pe.set(s, u), G.set(u, s)), u;
+  }
+  pn(() => {
+    const s = Ie.pool.value, u = s.length, y = ae.value;
+    let b = y.length !== u;
+    for (let M = 0; M < u; M++) {
+      const V = ct(s[M]);
+      y[M] !== V && (y[M] = V, b = !0);
+    }
+    y.length !== u && (y.length = u, b = !0), b && hn(ae);
+  });
+  const Tt = E(
+    () => Ie.visiblePool.value.map(ct)
+  ), F = /* @__PURE__ */ new WeakMap();
+  function Ae() {
+    z != null && (cancelAnimationFrame(z), w.delete(z), z = null);
+  }
+  function $() {
+    Ae(), T = null;
+  }
+  function it() {
+    T == null || z != null || (z = le(() => {
+      z = null, bt();
+    }));
+  }
+  function $e() {
+    const s = P.value;
+    if (!s)
+      return null;
+    const u = s.getBoundingClientRect();
+    let y = null;
+    for (const [b, M] of ve.entries()) {
+      if (!M.active || getComputedStyle(b).visibility === "hidden")
+        continue;
+      const V = b.getBoundingClientRect();
+      if (V.bottom <= u.top || V.top >= u.bottom)
+        continue;
+      const H = Math.max(V.top, u.top) - u.top;
+      (!y || H < y.score) && (y = {
+        key: M.id,
+        offset: V.top - u.top,
+        score: H
+      });
+    }
+    return y;
+  }
+  function rt(s) {
+    const u = P.value;
+    if (!u) {
+      $();
+      return;
+    }
+    const y = u.scrollTop, b = Math.min(Ie.findItemIndex(y), s.length - 1), M = s[b];
+    if (M == null) {
+      $();
+      return;
+    }
+    const V = $e();
+    T = {
+      logicalKey: M,
+      logicalOffset: y - Ie.getItemOffset(b),
+      pendingKeys: /* @__PURE__ */ new Set(),
+      stableFrames: 0,
+      visualKey: V?.key ?? null,
+      visualOffset: V?.offset ?? 0
+    };
+  }
+  function kt(s) {
+    const u = P.value;
+    return !u || Math.abs(u.scrollTop - s) < 0.5 ? !1 : (v = !0, u.scrollTop = s, Ie.updateVisibleItems(!0), u.dispatchEvent(new Event("scroll")), le(() => {
+      v = !1;
+    }), !0);
+  }
+  function bt() {
+    const s = T, u = P.value;
+    if (!s || !u)
+      return;
+    const y = O.value.findIndex((H) => H.id === s.logicalKey);
+    if (y === -1) {
+      $();
+      return;
+    }
+    let b = !1;
+    const M = Ie.getItemOffset(y) + s.logicalOffset;
+    if (b = kt(M) || b, !b && s.visualKey != null)
+      for (const [H, ye] of ve.entries()) {
+        if (!ye.active || ye.id !== s.visualKey || getComputedStyle(H).visibility === "hidden")
+          continue;
+        const ue = H.getBoundingClientRect().top - u.getBoundingClientRect().top - s.visualOffset;
+        b = kt(u.scrollTop + ue) || b;
+        break;
+      }
+    let V = !0;
+    for (const H of s.pendingKeys)
+      if (!(typeof I.sizes[H] == "number" && I.sizes[H] > 0)) {
+        V = !1;
+        break;
+      }
+    if (!b && V) {
+      if (s.stableFrames++, s.stableFrames >= 2) {
+        $();
+        return;
+      }
+    } else
+      s.stableFrames = 0;
+    it();
+  }
+  function De(s, u, y, b) {
+    const M = mi(), V = vt(u), H = At({
+      ...y
+    }), ye = At({
+      onResize: y.onResize
+    }), ue = vt(s), Te = M.run(() => (N(() => Tn(
+      V.value,
+      H,
+      S().keyField,
+      I.simpleArray,
+      I.active,
+      G
+    ), () => {
+      const Ve = ue.value;
+      if (Ve) {
+        const Le = Tn(
+          V.value,
+          H,
+          S().keyField,
+          I.simpleArray,
+          I.active,
+          G
+        ), Ee = Le.id;
+        Ee != null && ve.set(Ve, {
+          active: Le.active,
+          id: Ee
+        });
+      }
+    }, {
+      immediate: !0
+    }), N(() => Gi(
+      V.value,
+      B.value,
+      S().flowMode ?? !1,
+      G
+    ), () => {
+      const Ve = ue.value;
+      Ve && Mn(
+        Ve,
+        V.value,
+        B.value,
+        S().disableTransform ?? !1,
+        S().flowMode ?? !1,
+        b,
+        G
+      );
+    }, {
+      immediate: !0
+    }), $n(
+      H,
+      ue,
+      A,
+      ye
+    )));
+    Te.mount(), F.set(s, {
+      binding: V,
+      scope: M,
+      options: H,
+      callbacks: ye,
+      el: ue,
+      controller: Te,
+      restoreStyles: b
+    });
+  }
+  const Xe = {
+    mounted(s, u) {
+      if (!K.value)
+        return;
+      const y = _n(s);
+      De(s, u.value, kn(u.value, G), y);
+    },
+    updated(s, u) {
+      if (!K.value)
+        return;
+      const y = F.get(s), b = kn(u.value, G);
+      if (!y) {
+        const V = _n(s);
+        De(s, u.value, b, V);
+        return;
+      }
+      const M = y.binding.value !== u.value;
+      M && (y.binding.value = u.value), Qi(y.options, b), Xi(y.callbacks, b), y.el.value !== s && (y.el.value = s), M && Mn(
+        s,
+        u.value,
+        B.value,
+        S().disableTransform ?? !1,
+        S().flowMode ?? !1,
+        y.restoreStyles,
+        G
+      );
+    },
+    unmounted(s) {
+      const u = F.get(s);
+      u && (u.controller.unmount(), u.scope.stop(), Nn(s, u.restoreStyles), ve.delete(s), F.delete(s));
+    }
+  };
+  function qe(s = !1) {
+    K.value && ((s || Y.value) && (I.sizes = {}), l.emit("vscroll:update", { force: !0 }));
+  }
+  function zt(s, u) {
+    Ie.scrollToItem(s, u);
+  }
+  function wt(s) {
+    const u = S();
+    return I.sizes = Gt(s, C.value, Y.value ? null : u.keyField), Ie.restoreCache(s);
+  }
+  function Wt(s, u) {
+    const y = S(), b = u ?? C.value.indexOf(s), M = Y.value ? b : Jt(s, b >= 0 ? b : u, y.keyField);
+    return I.sizes[M] || 0;
+  }
+  function Ht() {
+    if (!K.value)
+      return;
+    const s = S(), u = s.pageMode ? An(P.value, R(s.scrollParent)) ?? window : P.value;
+    if (!u || c)
+      return;
+    c = !0;
+    const y = () => {
+      if (u === window) {
+        const M = document.documentElement;
+        return Math.max(M.scrollHeight, document.body?.scrollHeight ?? 0);
+      }
+      return u.scrollHeight;
+    }, b = (M) => {
+      u === window ? window.scrollTo({ top: M }) : u.scrollTop = M;
+    };
+    tt(() => {
+      b(y() + 5e3);
+      const M = () => {
+        b(y() + 5e3), le(() => {
+          b(y() + 5e3), i === 0 ? c = !1 : le(M);
+        });
+      };
+      le(M);
+    });
+  }
+  function Ze() {
+    T && !v && $();
+  }
+  return N(() => C.value.slice(), (s, u) => {
+    if (!K.value)
+      return;
+    const y = S(), b = Y.value ? null : y.keyField, M = et(s, b);
+    if (y.shift) {
+      const V = u ? et(u, b) : m, H = Dn(V, M);
+      H > 0 ? (rt(V), T && (T.pendingKeys = new Set(M.slice(0, H)), T.stableFrames = 0, tt(() => {
+        T && bt();
+      }))) : $();
+    } else
+      $();
+    m = M, qe();
+  }, { flush: "sync" }), N(() => S().cache, (s) => {
+    K.value && s && wt(s);
+  }), N(() => S().keyField, (s) => {
+    K.value && (I.keyField = s, m = et(C.value, Y.value ? null : s), $(), qe(!0));
+  }, { flush: "sync" }), N(Y, (s) => {
+    I.simpleArray = s;
+  }, { immediate: !0 }), N(() => S().direction, () => {
+    K.value && ($(), qe(!0));
+  }), N(P, (s, u) => {
+    u?.removeEventListener("scroll", Ze), K.value && s?.addEventListener("scroll", Ze);
+  }, {
+    immediate: !0
+  }), N(K, (s) => {
+    const u = P.value;
+    s ? (u?.addEventListener("scroll", Ze), qe()) : (u?.removeEventListener("scroll", Ze), Ae(), _e(), $());
+  }), N(f, () => {
+    if (!K.value)
+      return;
+    const s = P.value;
+    if (!s)
+      return;
+    if (T) {
+      bt();
+      return;
+    }
+    const u = g;
+    if (g = null, !u)
+      return;
+    const y = O.value.findIndex((V) => V.id === u.key);
+    if (y === -1)
+      return;
+    const b = Ie.getItemOffset(y) + u.offset;
+    b - s.scrollTop !== 0 && (s.scrollTop = b);
+  }, { flush: "post" }), Fn(() => {
+    I.active = !0;
+  }), di(() => {
+    I.active = !1;
+  }), fi(() => {
+    Ae(), _e(), P.value?.removeEventListener("scroll", Ze), l.clear();
+  }), {
+    vscrollData: I,
+    itemsWithSize: O,
+    resizeObserver: p,
+    measurementContext: A,
+    vDynamicScrollerItem: Xe,
+    ...Ie,
+    pool: ae,
+    visiblePool: Tt,
+    simpleArray: Y,
+    forceUpdate: qe,
+    scrollToItem: zt,
+    restoreCache: wt,
+    getItemSize: Wt,
+    getViewStyle: Oe,
+    scrollToBottom: Ht,
+    onScrollerResize: ie,
+    onScrollerVisible: xe
+  };
+}
+const ln = /* @__PURE__ */ new WeakMap();
+function er(e) {
+  return typeof e == "function" ? {
+    callback: e,
+    observer: null,
+    intersection: void 0,
+    visible: null
+  } : {
+    callback: e.callback,
+    observer: null,
+    intersection: e.intersection,
+    visible: null
+  };
+}
+function Rn(e, t) {
+  Un(e);
+  const i = er(t.value);
+  if (ln.set(e, i), typeof IntersectionObserver > "u") {
+    const n = e.getBoundingClientRect();
+    i.visible = !0, i.callback(!0, {
+      boundingClientRect: n
+    });
+    return;
+  }
+  i.observer = new IntersectionObserver((n) => {
+    const l = n[0], c = !!l?.isIntersecting;
+    i.visible !== null && i.visible === c || (i.visible = c, i.callback(c, l));
+  }, i.intersection), i.observer.observe(e);
+}
+function Un(e) {
+  const t = ln.get(e);
+  t?.observer && (t.observer.disconnect(), t.observer = null);
+}
+const jn = {
+  mounted(e, t) {
+    Rn(e, t);
+  },
+  updated(e, t) {
+    t.value !== t.oldValue && Rn(e, t);
+  },
+  unmounted(e) {
+    Un(e), ln.delete(e);
+  }
+}, qn = /* @__PURE__ */ St({
+  __name: "ItemView",
+  props: {
+    view: {},
+    itemTag: {}
+  },
+  setup(e) {
+    const t = e;
+    return (i, n) => (se(), Be(nt(t.itemTag), { class: "vue-recycle-scroller__item-view" }, {
+      default: Ue(() => [
+        Re(i.$slots, "default", {
+          item: t.view.item,
+          index: t.view.nr.index,
+          active: t.view.nr.used
+        })
+      ]),
+      _: 3
+    }));
+  }
+}), tr = /* @__PURE__ */ St({
+  __name: "ResizeObserver",
+  emits: ["notify"],
+  setup(e, { emit: t }) {
+    const i = t, n = Se();
+    let l = null, c = null;
+    function p() {
+      i("notify");
+    }
+    return Xt(() => {
+      const v = n.value?.parentElement;
+      if (v) {
+        if (typeof ResizeObserver < "u") {
+          l = new ResizeObserver(() => {
+            p();
+          }), l.observe(v);
+          return;
+        }
+        c = () => p(), window.addEventListener("resize", c);
+      }
+    }), Lt(() => {
+      l && (l.disconnect(), l = null), c && (window.removeEventListener("resize", c), c = null);
+    }), (v, m) => (se(), Qe("div", {
+      ref_key: "el",
+      ref: n,
+      class: "vue-recycle-scroller__resize-observer",
+      "aria-hidden": "true"
+    }, null, 512));
+  }
+}), nr = (e, t) => {
+  const i = e.__vccOpts || e;
+  for (const [n, l] of t)
+    i[n] = l;
+  return i;
+}, Kn = /* @__PURE__ */ nr(tr, [["__scopeId", "data-v-08cc04ab"]]), ir = /* @__PURE__ */ St({
+  __name: "RecycleScroller",
+  props: {
+    items: {},
+    keyField: { default: "id" },
+    direction: { default: "vertical" },
+    listTag: { default: "div" },
+    itemTag: { default: "div" },
+    itemSize: { default: null },
+    gridItems: { default: void 0 },
+    itemSecondarySize: { default: void 0 },
+    minItemSize: { default: null },
+    sizeField: { default: "size" },
+    typeField: { default: "type" },
+    buffer: { default: 200 },
+    pageMode: { type: Boolean, default: !1 },
+    scrollParent: { default: void 0 },
+    shift: { type: Boolean, default: !1 },
+    cache: { default: void 0 },
+    prerender: { default: 0 },
+    emitUpdate: { type: Boolean, default: !1 },
+    disableTransform: { type: Boolean, default: !1 },
+    flowMode: { type: Boolean, default: !1 },
+    hiddenPosition: { default: void 0 },
+    updateInterval: { default: 0 },
+    itemsLimit: { default: void 0 },
+    skipHover: { type: Boolean, default: !1 },
+    enabled: { type: Boolean, default: !0 },
+    listClass: { default: "" },
+    itemClass: { default: "" }
+  },
+  emits: ["resize", "visible", "hidden", "update", "scrollStart", "scrollEnd"],
+  setup(e, { expose: t, emit: i }) {
+    const n = e, l = i, c = jn, p = Se(), v = Se(), m = Se(), g = Se(null), T = Zt(n, "items"), z = E(() => ({
+      items: T,
+      el: p,
+      before: v,
+      after: m,
+      keyField: n.keyField,
+      direction: n.direction,
+      itemSize: n.itemSize,
+      gridItems: n.gridItems,
+      itemSecondarySize: n.itemSecondarySize,
+      minItemSize: n.minItemSize,
+      sizeField: n.sizeField,
+      typeField: n.typeField,
+      buffer: n.buffer,
+      pageMode: n.pageMode,
+      scrollParent: n.scrollParent,
+      shift: n.shift,
+      cache: n.cache,
+      prerender: n.prerender,
+      emitUpdate: n.emitUpdate,
+      disableTransform: n.disableTransform,
+      flowMode: n.flowMode,
+      hiddenPosition: n.hiddenPosition,
+      updateInterval: n.updateInterval,
+      itemsLimit: n.itemsLimit,
+      enabled: n.enabled,
+      onResize: () => l("resize"),
+      onVisible: () => l("visible"),
+      onHidden: () => l("hidden"),
+      onUpdate: (G, Pe, ae, Oe) => {
+        l("update", G, Pe, ae, Oe), ae <= 0 && l("scrollStart"), Oe >= n.items.length - 1 && l("scrollEnd");
+      }
+    })), w = rn(
+      z
+    ), {
+      pool: k,
+      visiblePool: I,
+      totalSize: C,
+      startSpacerSize: B,
+      endSpacerSize: P,
+      ready: q,
+      scrollToItem: te,
+      scrollToPosition: ve,
+      getScroll: S,
+      findItemIndex: K,
+      getItemOffset: le,
+      getItemSize: _e,
+      getViewStyle: Ce,
+      cacheSnapshot: A,
+      restoreCache: Y,
+      updateVisibleItems: f,
+      handleResize: O,
+      handleVisibilityChange: J
+    } = w, ne = E(
+      () => yt({
+        direction: n.direction,
+        disableTransform: n.disableTransform,
+        flowMode: n.flowMode,
+        gridItems: n.gridItems
+      }) === "flow"
+    ), je = E(() => ({
+      height: `${B.value}px`
+    })), pe = E(() => ({
+      height: `${P.value}px`
+    }));
+    function Me(G) {
+      g.value = G;
+    }
+    function ie() {
+      g.value = null;
+    }
+    const xe = E(() => {
+      const G = {
+        [n.direction === "vertical" ? "minHeight" : "minWidth"]: `${C.value}px`
+      }, Pe = He(n.itemSize);
+      if (n.gridItems && Pe != null) {
+        const ae = (n.itemSecondarySize || Pe) * n.gridItems;
+        G[n.direction === "vertical" ? "minWidth" : "minHeight"] = `${ae}px`;
+      }
+      return G;
+    });
+    return t({
+      el: p,
+      visiblePool: I,
+      startSpacerSize: B,
+      endSpacerSize: P,
+      scrollToItem: te,
+      scrollToPosition: ve,
+      getScroll: S,
+      findItemIndex: K,
+      getItemOffset: le,
+      getItemSize: _e,
+      cacheSnapshot: A,
+      restoreCache: Y,
+      updateVisibleItems: f
+    }), (G, Pe) => Cn((se(), Qe("div", {
+      ref_key: "el",
+      ref: p,
+      class: xt(["vue-recycle-scroller", {
+        "grid-mode": n.gridItems,
+        "flow-mode": ne.value,
+        ready: ee(q),
+        "page-mode": n.pageMode,
+        [`direction-${n.direction}`]: !0
+      }])
+    }, [
+      G.$slots.before ? (se(), Qe("div", {
+        key: 0,
+        ref_key: "before",
+        ref: v,
+        class: "vue-recycle-scroller__slot"
+      }, [
+        Re(G.$slots, "before")
+      ], 512)) : Ne("", !0),
+      (se(), Be(nt(n.listTag), {
+        style: ut(xe.value),
+        class: xt(["vue-recycle-scroller__item-wrapper", n.listClass])
+      }, {
+        default: Ue(() => [
+          ne.value && ee(B) > 0 ? (se(), Be(nt(n.itemTag), {
+            key: 0,
+            "aria-hidden": "true",
+            class: "vue-recycle-scroller__item-spacer",
+            style: ut(je.value)
+          }, null, 8, ["style"])) : Ne("", !0),
+          (se(!0), Qe(Vn, null, Pn(ee(k), (ae) => (se(), Be(qn, $t({
+            key: ae.nr.id,
+            view: ae,
+            "item-tag": n.itemTag,
+            style: ee(q) ? ee(Ce)(ae) : null,
+            class: ["vue-recycle-scroller__item-view", [
+              n.itemClass,
+              {
+                hover: !n.skipHover && g.value === ae.nr.key
+              }
+            ]]
+          }, vi(n.skipHover ? {} : {
+            mouseenter: () => {
+              Me(ae.nr.key);
+            },
+            mouseleave: () => {
+              ie();
+            }
+          })), {
+            default: Ue((Oe) => [
+              Re(G.$slots, "default", $t({ ref_for: !0 }, Oe))
+            ]),
+            _: 3
+          }, 16, ["view", "item-tag", "style", "class"]))), 128)),
+          ne.value && ee(P) > 0 ? (se(), Be(nt(n.itemTag), {
+            key: 1,
+            "aria-hidden": "true",
+            class: "vue-recycle-scroller__item-spacer",
+            style: ut(pe.value)
+          }, null, 8, ["style"])) : Ne("", !0),
+          n.items.length === 0 ? Re(G.$slots, "empty", {}, void 0, void 0, 2) : Ne("", !0)
+        ]),
+        _: 3
+      }, 8, ["style", "class"])),
+      G.$slots.after ? (se(), Qe("div", {
+        key: 1,
+        ref_key: "after",
+        ref: m,
+        class: "vue-recycle-scroller__slot"
+      }, [
+        Re(G.$slots, "after")
+      ], 512)) : Ne("", !0),
+      On(Kn, { onNotify: ee(O) }, null, 8, ["onNotify"])
+    ], 2)), [
+      [ee(c), ee(J)]
+    ]);
+  }
+}), vr = /* @__PURE__ */ St({
+  inheritAttrs: !1,
+  __name: "DynamicScroller",
+  props: {
+    items: {},
+    keyField: { default: "id" },
+    direction: { default: "vertical" },
+    listTag: { default: "div" },
+    itemTag: { default: "div" },
+    minItemSize: {},
+    shift: { type: Boolean, default: !1 },
+    cache: { default: void 0 },
+    disableTransform: { type: Boolean, default: !1 },
+    flowMode: { type: Boolean, default: !1 },
+    hiddenPosition: { default: void 0 },
+    enabled: { type: Boolean, default: !0 },
+    pageMode: { type: Boolean, default: !1 },
+    scrollParent: { default: void 0 }
+  },
+  emits: ["resize", "visible"],
+  setup(e, { expose: t, emit: i }) {
+    const n = e, l = i, c = Se(), p = Zt(n, "items"), v = E(() => {
+      const A = c.value?.el;
+      return A && typeof A == "object" && "value" in A ? A.value : A;
+    }), m = E(() => ({
+      items: p,
+      keyField: n.keyField,
+      direction: n.direction,
+      minItemSize: n.minItemSize,
+      shift: n.shift,
+      cache: n.cache,
+      flowMode: n.flowMode,
+      hiddenPosition: n.hiddenPosition,
+      enabled: n.enabled,
+      pageMode: n.pageMode,
+      scrollParent: n.scrollParent,
+      el: v.value,
+      onResize: () => l("resize"),
+      onVisible: () => l("visible")
+    })), g = Ji(
+      m
+    ), {
+      itemsWithSize: T,
+      forceUpdate: z,
+      startSpacerSize: w,
+      endSpacerSize: k,
+      scrollToItem: I,
+      scrollToPosition: C,
+      findItemIndex: B,
+      getItemOffset: P,
+      getItemSize: q,
+      cacheSnapshot: te,
+      restoreCache: ve,
+      scrollToBottom: S,
+      onScrollerResize: K,
+      onScrollerVisible: le
+    } = g;
+    function _e(A, Y, f) {
+      return {
+        item: A.item,
+        index: Y,
+        active: f,
+        itemWithSize: A
+      };
+    }
+    return t({
+      startSpacerSize: w,
+      endSpacerSize: k,
+      scrollToItem: I,
+      scrollToPosition: C,
+      findItemIndex: B,
+      getItemOffset: P,
+      scrollToBottom: S,
+      getItemSize: q,
+      cacheSnapshot: te,
+      restoreCache: ve,
+      forceUpdate: z
+    }), (A, Y) => (se(), Be(ir, $t({
+      ref_key: "scroller",
+      ref: c,
+      items: ee(T),
+      "min-item-size": n.minItemSize,
+      direction: n.direction,
+      cache: n.cache,
+      "disable-transform": n.disableTransform,
+      "flow-mode": n.flowMode,
+      "hidden-position": n.hiddenPosition,
+      enabled: n.enabled,
+      "page-mode": n.pageMode,
+      "scroll-parent": n.scrollParent,
+      "key-field": "id",
+      "list-tag": n.listTag,
+      "item-tag": n.itemTag
+    }, A.$attrs, {
+      onResize: ee(K),
+      onVisible: ee(le)
+    }), pi({
+      default: Ue(({ item: f, index: O, active: J }) => [
+        Re(A.$slots, "default", hi(yi(_e(f, O, J))))
+      ]),
+      empty: Ue(() => [
+        Re(A.$slots, "empty")
+      ]),
+      _: 2
+    }, [
+      A.$slots.before ? {
+        name: "before",
+        fn: Ue(() => [
+          Re(A.$slots, "before")
+        ]),
+        key: "0"
+      } : void 0,
+      A.$slots.after ? {
+        name: "after",
+        fn: Ue(() => [
+          Re(A.$slots, "after")
+        ]),
+        key: "1"
+      } : void 0
+    ]), 1040, ["items", "min-item-size", "direction", "cache", "disable-transform", "flow-mode", "hidden-position", "enabled", "page-mode", "scroll-parent", "list-tag", "item-tag", "onResize", "onVisible"]));
+  }
+});
+function rr(e, t, i) {
+  const n = yn("vscrollMeasurementContext"), l = yn("vscrollAnchorRegistry", null), c = E(() => {
+    const w = R(e).el;
+    return R(t ?? w);
+  }), p = {
+    onResize: (w) => (i?.onResize ?? R(e).onResize)?.(w)
+  }, v = E(() => R(
+    R(e).enabled ?? !0
+  )), m = $n(e, c, n, p);
+  let g = !1;
+  function T() {
+    g || (m.mount(), g = !0);
+  }
+  function z() {
+    g && (m.unmount(), g = !1);
+  }
+  return Xt(() => {
+    v.value && T();
+  }), N(v, (w) => {
+    if (w)
+      T();
+    else {
+      const k = c.value;
+      l && k && l.delete(k), z();
+    }
+  }), l && N(
+    [m.id, m.finalActive, c, v],
+    ([w, k, I, C], [B, P, q]) => {
+      q && q !== I && l.delete(q), C && I && l.set(I, {
+        active: k,
+        id: w
+      });
+    },
+    {
+      immediate: !0
+    }
+  ), Lt(() => {
+    const w = c.value;
+    l && w && l.delete(w), z();
+  }), {
+    id: m.id,
+    size: m.size,
+    finalActive: m.finalActive,
+    updateSize: m.updateSize
+  };
+}
+const pr = /* @__PURE__ */ St({
+  __name: "DynamicScrollerItem",
+  props: {
+    item: {},
+    watchData: { type: Boolean, default: !1 },
+    active: { type: Boolean },
+    index: { default: void 0 },
+    sizeDependencies: { default: null },
+    emitResize: { type: Boolean, default: !1 },
+    enabled: { type: Boolean, default: !0 },
+    tag: { default: "div" }
+  },
+  emits: ["resize"],
+  setup(e, { emit: t }) {
+    const i = e, n = t, l = Se();
+    return rr(
+      i,
+      l,
+      {
+        onResize: (c) => n("resize", c)
+      }
+    ), (c, p) => (se(), Be(nt(i.tag), {
+      ref_key: "el",
+      ref: l
+    }, {
+      default: Ue(() => [
+        Re(c.$slots, "default")
+      ]),
+      _: 3
+    }, 512));
+  }
+});
+function lr(e, t, i, n, l) {
+  return rn(
+    e,
+    t,
+    i,
+    n,
+    l,
+    {
+      pageMode: !0
+    }
+  );
+}
+const hr = /* @__PURE__ */ St({
+  __name: "WindowScroller",
+  props: {
+    items: {},
+    keyField: { default: "id" },
+    direction: { default: "vertical" },
+    listTag: { default: "div" },
+    itemTag: { default: "div" },
+    itemSize: { default: null },
+    gridItems: { default: void 0 },
+    itemSecondarySize: { default: void 0 },
+    minItemSize: { default: null },
+    sizeField: { default: "size" },
+    typeField: { default: "type" },
+    buffer: { default: 200 },
+    shift: { type: Boolean, default: !1 },
+    cache: { default: void 0 },
+    prerender: { default: 0 },
+    emitUpdate: { type: Boolean, default: !1 },
+    disableTransform: { type: Boolean, default: !1 },
+    flowMode: { type: Boolean, default: !1 },
+    hiddenPosition: { default: void 0 },
+    updateInterval: { default: 0 },
+    itemsLimit: { default: void 0 },
+    enabled: { type: Boolean, default: !0 },
+    listClass: { default: "" },
+    itemClass: { default: "" }
+  },
+  emits: ["resize", "visible", "hidden", "update"],
+  setup(e, { expose: t, emit: i }) {
+    const n = e, l = i, c = jn, p = Se(), v = Se(), m = Se(), g = Zt(n, "items"), T = E(() => ({
+      items: g,
+      el: p,
+      before: v,
+      after: m,
+      keyField: n.keyField,
+      direction: n.direction,
+      itemSize: n.itemSize,
+      gridItems: n.gridItems,
+      itemSecondarySize: n.itemSecondarySize,
+      minItemSize: n.minItemSize,
+      sizeField: n.sizeField,
+      typeField: n.typeField,
+      buffer: n.buffer,
+      shift: n.shift,
+      cache: n.cache,
+      prerender: n.prerender,
+      emitUpdate: n.emitUpdate,
+      disableTransform: n.disableTransform,
+      flowMode: n.flowMode,
+      hiddenPosition: n.hiddenPosition,
+      updateInterval: n.updateInterval,
+      itemsLimit: n.itemsLimit,
+      enabled: n.enabled,
+      onResize: () => l("resize"),
+      onVisible: () => l("visible"),
+      onHidden: () => l("hidden"),
+      onUpdate: (pe, Me, ie, xe) => l("update", pe, Me, ie, xe)
+    })), z = lr(
+      T
+    ), {
+      pool: w,
+      totalSize: k,
+      startSpacerSize: I,
+      endSpacerSize: C,
+      ready: B,
+      scrollToItem: P,
+      scrollToPosition: q,
+      getScroll: te,
+      findItemIndex: ve,
+      getItemOffset: S,
+      getItemSize: K,
+      getViewStyle: le,
+      cacheSnapshot: _e,
+      restoreCache: Ce,
+      updateVisibleItems: A,
+      handleResize: Y,
+      handleVisibilityChange: f
+    } = z, O = E(
+      () => yt({
+        direction: n.direction,
+        disableTransform: n.disableTransform,
+        flowMode: n.flowMode,
+        gridItems: n.gridItems
+      }) === "flow"
+    ), J = E(() => ({
+      height: `${I.value}px`
+    })), ne = E(() => ({
+      height: `${C.value}px`
+    }));
+    return t({
+      el: p,
+      startSpacerSize: I,
+      endSpacerSize: C,
+      scrollToItem: P,
+      scrollToPosition: q,
+      getScroll: te,
+      findItemIndex: ve,
+      getItemOffset: S,
+      getItemSize: K,
+      cacheSnapshot: _e,
+      restoreCache: Ce,
+      updateVisibleItems: A
+    }), (pe, Me) => Cn((se(), Qe("div", {
+      ref_key: "el",
+      ref: p,
+      class: xt(["vue-recycle-scroller vue-window-scroller", {
+        "flow-mode": O.value,
+        ready: ee(B),
+        [`direction-${n.direction}`]: !0
+      }])
+    }, [
+      pe.$slots.before ? (se(), Qe("div", {
+        key: 0,
+        ref_key: "before",
+        ref: v,
+        class: "vue-recycle-scroller__slot"
+      }, [
+        Re(pe.$slots, "before")
+      ], 512)) : Ne("", !0),
+      (se(), Be(nt(n.listTag), {
+        style: ut({ [n.direction === "vertical" ? "minHeight" : "minWidth"]: `${ee(k)}px` }),
+        class: xt(["vue-recycle-scroller__item-wrapper", n.listClass])
+      }, {
+        default: Ue(() => [
+          O.value && ee(I) > 0 ? (se(), Be(nt(n.itemTag), {
+            key: 0,
+            "aria-hidden": "true",
+            class: "vue-recycle-scroller__item-spacer",
+            style: ut(J.value)
+          }, null, 8, ["style"])) : Ne("", !0),
+          (se(!0), Qe(Vn, null, Pn(ee(w), (ie) => (se(), Be(qn, {
+            key: ie.nr.id,
+            view: ie,
+            "item-tag": n.itemTag,
+            style: ut(ee(B) ? ee(le)(ie) : null),
+            class: xt(["vue-recycle-scroller__item-view", n.itemClass])
+          }, {
+            default: Ue((xe) => [
+              Re(pe.$slots, "default", $t({ ref_for: !0 }, xe))
+            ]),
+            _: 3
+          }, 8, ["view", "item-tag", "style", "class"]))), 128)),
+          O.value && ee(C) > 0 ? (se(), Be(nt(n.itemTag), {
+            key: 1,
+            "aria-hidden": "true",
+            class: "vue-recycle-scroller__item-spacer",
+            style: ut(ne.value)
+          }, null, 8, ["style"])) : Ne("", !0),
+          n.items.length === 0 ? Re(pe.$slots, "empty", {}, void 0, void 0, 2) : Ne("", !0)
+        ]),
+        _: 3
+      }, 8, ["style", "class"])),
+      pe.$slots.after ? (se(), Qe("div", {
+        key: 1,
+        ref_key: "after",
+        ref: m,
+        class: "vue-recycle-scroller__slot"
+      }, [
+        Re(pe.$slots, "after")
+      ], 512)) : Ne("", !0),
+      On(Kn, { onNotify: ee(Y) }, null, 8, ["onNotify"])
+    ], 2)), [
+      [ee(c), ee(f)]
+    ]);
+  }
+});
+function yr({
+  idProp: e = (t) => t.item.id
+} = {}) {
+  const t = Yt({}), i = Se(null);
+  let n = null;
+  const l = gi();
+  if (!l)
+    throw new Error("[useIdState] Must be called inside setup()");
+  const c = typeof e == "function" ? () => e(l.proxy) : () => l.proxy[e];
+  function p(m) {
+    const g = l.proxy.$options.idState;
+    if (typeof g == "function") {
+      const T = g.call(l.proxy, l.proxy);
+      return t[m] = T, n = m, T;
+    } else
+      throw new TypeError("[useIdState] Missing `idState` function on component definition.");
+  }
+  function v() {
+    const m = c();
+    m == null && console.warn(`No id found for IdState with idProp: '${e}'.`), m !== n && (t[m] || p(m), i.value = t[m]);
+  }
+  return N(c, (m) => {
+    tt(() => {
+      n = m;
+    });
+  }, { immediate: !0 }), v(), Si(() => {
+    v();
+  }), {
+    idState: i
+  };
+}
+function or() {
+  return new Promise((e) => {
+    requestAnimationFrame(() => e());
+  });
+}
+function sr(e) {
+  if (e.borderBoxSize) {
+    const t = Array.isArray(e.borderBoxSize) ? e.borderBoxSize[0] : e.borderBoxSize;
+    if (t)
+      return t.inlineSize;
+  }
+  return e.contentRect.width;
+}
+function Yn(e) {
+  return (e.tHead ? [...e.tHead.rows] : []).at(-1) ?? null;
+}
+function Gn(e, t) {
+  if (e.getAttribute("aria-hidden") === "true" || e.cells.length !== t)
+    return !1;
+  const i = getComputedStyle(e);
+  return i.display === "none" || i.visibility === "hidden" ? !1 : e.getBoundingClientRect().width > 0;
+}
+function ar(e) {
+  if (e.getAttribute("aria-hidden") === "true" || e.cells.length === 0)
+    return !1;
+  const t = getComputedStyle(e);
+  return t.display === "none" || t.visibility === "hidden" ? !1 : e.getBoundingClientRect().width > 0;
+}
+function ur(e, t) {
+  for (const i of [...e.tBodies])
+    for (const n of [...i.rows])
+      if (Gn(n, t))
+        return n;
+  return null;
+}
+function cr(e) {
+  const t = Yn(e);
+  if (t?.cells.length)
+    return t.cells.length;
+  for (const i of [...e.tBodies])
+    for (const n of [...i.rows])
+      if (ar(n))
+        return n.cells.length;
+  return 0;
+}
+function En(e, t) {
+  for (const [i, n] of [...e.cells].entries())
+    t[i] = Math.max(t[i] ?? 0, Math.ceil(n.getBoundingClientRect().width));
+}
+function dr(e) {
+  const t = cr(e);
+  if (!t)
+    return [];
+  const i = Array.from({ length: t }, (c, p) => p).fill(0), n = Yn(e);
+  if (n && n.cells.length === t && n.getBoundingClientRect().width > 0 && En(n, i), !ur(e, t) && !n)
+    return [];
+  for (const c of [...e.tBodies])
+    for (const p of [...c.rows])
+      Gn(p, t) && En(p, i);
+  return i.some((c) => c > 0) ? i : [];
+}
+function gr(e) {
+  const t = vt([]), i = E(() => t.value), n = E(() => t.value.length > 0), l = E(() => t.value.length > 0 ? { tableLayout: "fixed" } : void 0);
+  function c() {
+    return R(e.disabled) || R(e.enabled ?? !0) === !1;
+  }
+  let p = !0, v = null, m = null, g = !1, T = !1, z = !1;
+  const w = typeof ResizeObserver > "u" ? void 0 : new ResizeObserver((B) => {
+    for (const P of B) {
+      if (P.target !== v)
+        continue;
+      const q = sr(P);
+      q !== m && (m = q, C());
+    }
+  });
+  function k() {
+    t.value = [];
+  }
+  async function I() {
+    if (T) {
+      z = !0;
+      return;
+    }
+    T = !0, k(), await tt(), await or(), g = !1;
+    const B = R(e.table);
+    p && B && !c() && (t.value = dr(B)), T = !1, z && (z = !1, C());
+  }
+  function C() {
+    if (p) {
+      if (c() || !R(e.table)) {
+        k();
+        return;
+      }
+      if (g) {
+        z = !0;
+        return;
+      }
+      g = !0, I();
+    }
+  }
+  return N(
+    () => [R(e.table), c()],
+    ([B, P], q) => {
+      const te = q?.[0];
+      if (te && w && w.unobserve(te), v = B ?? null, m = B?.getBoundingClientRect().width ?? null, !B || P) {
+        k();
+        return;
+      }
+      w?.observe(B), C();
+    },
+    {
+      immediate: !0,
+      flush: "post"
+    }
+  ), N(
+    () => R(e.dependencies) ?? null,
+    () => {
+      !c() && R(e.table) && C();
+    },
+    {
+      deep: !0,
+      flush: "post"
+    }
+  ), Lt(() => {
+    p = !1, w?.disconnect();
+  }), {
+    columnWidths: i,
+    hasLockedWidths: n,
+    tableStyle: l,
+    scheduleMeasure: C,
+    clear: k
+  };
+}
+export {
+  vr as DynamicScroller,
+  pr as DynamicScrollerItem,
+  ir as RecycleScroller,
+  hr as WindowScroller,
+  Ji as useDynamicScroller,
+  rr as useDynamicScrollerItem,
+  yr as useIdState,
+  rn as useRecycleScroller,
+  gr as useTableColumnWidths,
+  lr as useWindowScroller
+};