x-sccba 0.1.1 → 0.2.3

package/dist/vue2/index244.mjs

@@ -0,0 +1,849 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { reactive, computed, toValue, provide, shallowRef, watchEffect, shallowReactive, triggerRef, watch, nextTick, onActivated, onDeactivated, onUnmounted, effectScope } from "vue";
+import { a as Ut, b as Be, d as bn, u as qn, f as zn, e as Tn, r as Mn } from "./index243.mjs";
+import { r as f, a as e } from "./index256.mjs";
+import { c as q } from "./index257.mjs";
+function et() {
+  const n = /* @__PURE__ */ new Map();
+  return {
+    on(i, l) {
+      let a = n.get(i);
+      a || (a = /* @__PURE__ */ new Set(), n.set(i, a)), a.add(l);
+    },
+    off(i, l) {
+      const a = n.get(i);
+      a && (a.delete(l), a.size || n.delete(i));
+    },
+    emit(i, l) {
+      const a = n.get(i);
+      if (a != null && a.size)
+        for (const d of [...a])
+          d(l);
+    },
+    clear() {
+      n.clear();
+    }
+  };
+}
+function tt(n = {}) {
+  var _a, _b, _c;
+  const i = (_a = n.queueFlush) != null ? _a : (m) => nextTick(m), l = (_b = n.overflowQueueFlush) != null ? _b : i, a = Math.max(1, (_c = n.maxTasksPerFlush) != null ? _c : Number.POSITIVE_INFINITY);
+  let d = false;
+  const p = /* @__PURE__ */ new Map();
+  function w() {
+    d || !p.size || (d = true, i(x));
+  }
+  function x() {
+    if (d = false, !p.size)
+      return;
+    const m = [];
+    for (const [g, I] of p)
+      if (m.push(I), p.delete(g), m.length >= a)
+        break;
+    const R = m.map((g) => ({
+      task: g,
+      value: g.read()
+    }));
+    for (const g of R)
+      g.value != null && g.task.write(g.value), g.task.done();
+    p.size && (l(x), d = true);
+  }
+  function D(m, R) {
+    p.set(m, R), w();
+  }
+  function y(m) {
+    p.delete(m);
+  }
+  return {
+    schedule: D,
+    cancel: y
+  };
+}
+function nt(n) {
+  for (let i = 0; i < n.length; i++)
+    n[i];
+}
+function Fe(n) {
+  return n.item;
+}
+function Q(n, i) {
+  const l = i.get(n);
+  return l || n;
+}
+function it(n) {
+  const i = {};
+  return Object.defineProperties(i, {
+    item: {
+      enumerable: true,
+      get: () => n.item.item
+    },
+    itemWithSize: {
+      enumerable: true,
+      get: () => n.item
+    },
+    size: {
+      enumerable: true,
+      get: () => n.item.size
+    },
+    position: {
+      enumerable: true,
+      get: () => n.position
+    },
+    offset: {
+      enumerable: true,
+      get: () => n.offset
+    },
+    id: {
+      enumerable: true,
+      get: () => n.nr.id
+    },
+    index: {
+      enumerable: true,
+      get: () => n.nr.index
+    },
+    used: {
+      enumerable: true,
+      get: () => n.nr.used
+    },
+    key: {
+      enumerable: true,
+      get: () => n.nr.key
+    },
+    type: {
+      enumerable: true,
+      get: () => n.nr.type
+    }
+  }), i;
+}
+function rt(n) {
+  var _a;
+  return (_a = n._vs_styleStamp) != null ? _a : 0;
+}
+function st(n) {
+  var _a;
+  return (_a = n._vs_visibilityStamp) != null ? _a : 0;
+}
+const Te = [
+  "position",
+  "top",
+  "left",
+  "transform",
+  "willChange",
+  "visibility",
+  "pointerEvents",
+  "display"
+];
+function Se(n) {
+  const i = {};
+  for (const l of Te)
+    i[l] = n.style[l];
+  return i;
+}
+function _e(n, i) {
+  var _a;
+  for (const l of Te)
+    n.style[l] = (_a = i[l]) != null ? _a : "";
+}
+function U(n, i, l) {
+  n.style[i] !== l && (n.style[i] = l);
+}
+function ze(n, i, l, a, d, p, w) {
+  var _a, _b, _c, _d, _e2, _f, _g, _h;
+  if (!("view" in i)) {
+    _e(n, p);
+    return;
+  }
+  const x = n.tagName === "TR", D = d ? Mn({
+    direction: l,
+    flowMode: true
+  }) : Mn({
+    direction: l,
+    disableTransform: a || x
+  }), y = Tn(Q(i.view, w), {
+    direction: l,
+    mode: D
+  });
+  U(n, "position", String((_a = y.position) != null ? _a : "")), U(n, "top", String((_b = y.top) != null ? _b : "")), U(n, "left", String((_c = y.left) != null ? _c : "")), U(n, "transform", D === "flow" || x ? "" : String((_d = y.transform) != null ? _d : "")), U(n, "willChange", String((_e2 = y.willChange) != null ? _e2 : "")), U(n, "visibility", String((_f = y.visibility) != null ? _f : "")), U(n, "pointerEvents", String((_g = y.pointerEvents) != null ? _g : "")), U(n, "display", String((_h = y.display) != null ? _h : ""));
+}
+function be(n, i) {
+  return "view" in n && !i;
+}
+function we(n, i, l, a, d, p) {
+  if ("view" in n) {
+    const w = Q(n.view, p);
+    return {
+      active: w.nr.used && d,
+      id: Fe(w).id
+    };
+  }
+  return {
+    active: i.active && d,
+    id: ut(
+      i.item,
+      l,
+      a,
+      i.index
+    )
+  };
+}
+function lt(n, i, l, a) {
+  if (!("view" in n))
+    return {
+      direction: i,
+      flowMode: l,
+      legacy: true
+    };
+  if (l) {
+    const p = Q(n.view, a);
+    return {
+      direction: i,
+      flowMode: l,
+      legacy: false,
+      visibilityStamp: st(p)
+    };
+  }
+  const d = Q(n.view, a);
+  return {
+    active: d.nr.used,
+    direction: i,
+    flowMode: l,
+    legacy: false,
+    styleStamp: rt(d),
+    position: be(n, l) ? d.position : null,
+    offset: be(n, l) ? d.offset : null
+  };
+}
+function Re(n, i) {
+  var _a, _b, _c;
+  if ("view" in n) {
+    const l = Q(n.view, i);
+    return {
+      item: Fe(l).item,
+      active: l.nr.used,
+      index: l.nr.index,
+      watchData: (_a = n.watchData) != null ? _a : false,
+      emitResize: (_b = n.emitResize) != null ? _b : false,
+      sizeDependencies: (_c = n.sizeDependencies) != null ? _c : null,
+      onResize: n.onResize
+    };
+  }
+  return __spreadValues({
+    watchData: false,
+    emitResize: false,
+    sizeDependencies: null
+  }, n);
+}
+function ot(n, i) {
+  n.item !== i.item && (n.item = i.item), n.active !== i.active && (n.active = i.active), n.index !== i.index && (n.index = i.index), n.watchData !== i.watchData && (n.watchData = i.watchData), n.sizeDependencies !== i.sizeDependencies && (n.sizeDependencies = i.sizeDependencies), n.emitResize !== i.emitResize && (n.emitResize = i.emitResize), n.onResize !== i.onResize && (n.onResize = i.onResize);
+}
+function ct(n, i) {
+  n.onResize !== i.onResize && (n.onResize = i.onResize);
+}
+function ut(n, i, l, a) {
+  return l ? a != null ? a : null : e(n, a, i);
+}
+function vt(n) {
+  const i = Ut(n);
+  let l = 0, a = {};
+  const d = et();
+  let p = false, w, x = false, D = [], y = null, m = null, R = null;
+  const g = /* @__PURE__ */ new Set(), I = [], v = reactive({
+    active: true,
+    sizes: {},
+    keyField: o().keyField,
+    simpleArray: false
+  }), C = computed(() => {
+    const e2 = toValue(o().items);
+    return nt(e2), e2;
+  }), E = computed(() => {
+    var _a;
+    return (_a = o().direction) != null ? _a : "vertical";
+  }), b = computed(() => toValue(o().el)), Me = computed(() => toValue(o().before)), Ae = computed(() => toValue(o().after)), H = /* @__PURE__ */ new Map();
+  function o() {
+    return i.value;
+  }
+  const z = computed(() => {
+    var _a;
+    return toValue((_a = o().enabled) != null ? _a : true);
+  });
+  function $(e2) {
+    let t = -1;
+    return t = requestAnimationFrame(() => {
+      g.delete(t), e2();
+    }), g.add(t), t;
+  }
+  function le() {
+    for (const e2 of g)
+      cancelAnimationFrame(e2);
+    g.clear();
+  }
+  const xe = tt({
+    // Spread row measurement across frames so one huge flush cannot monopolize layout time.
+    maxTasksPerFlush: 6,
+    overflowQueueFlush(e2) {
+      $(e2);
+    }
+  });
+  typeof ResizeObserver < "u" && (w = new ResizeObserver((e2) => {
+    $(() => {
+      if (Array.isArray(e2)) {
+        for (const t of e2)
+          if (t.target && t.target.$_vs_onResize) {
+            let r, s;
+            if (t.borderBoxSize) {
+              const u = t.borderBoxSize[0];
+              r = u.inlineSize, s = u.blockSize;
+            } else
+              r = t.contentRect.width, s = t.contentRect.height;
+            t.target.$_vs_onResize(t.target.$_vs_id, r, s);
+          }
+      }
+    });
+  }));
+  const Z = {
+    vscrollData: v,
+    resizeObserver: w,
+    measureQueue: xe,
+    direction: E,
+    undefinedMap: a,
+    undefinedSizeCount: {
+      get value() {
+        return l;
+      },
+      set value(e2) {
+        l = e2;
+      }
+    },
+    onVscrollUpdate(e2) {
+      const t = (r) => {
+        e2(r);
+      };
+      return d.on("vscroll:update", t), () => d.off("vscroll:update", t);
+    }
+  };
+  provide("vscrollData", v), provide("vscrollParent", {
+    get $_undefinedSizes() {
+      return l;
+    },
+    set $_undefinedSizes(e2) {
+      l = e2;
+    },
+    get $_undefinedMap() {
+      return a;
+    },
+    set $_undefinedMap(e2) {
+      a = e2;
+    },
+    $_events: d,
+    direction: E
+  }), provide("vscrollResizeObserver", w), provide("vscrollMeasurementContext", Z), provide("vscrollAnchorRegistry", {
+    delete(e2) {
+      H.delete(e2);
+    },
+    set(e2, t) {
+      H.set(e2, t);
+    }
+  });
+  const k = computed(() => {
+    const e2 = C.value;
+    return e2.length > 0 && typeof e2[0] != "object";
+  }), oe = shallowRef(0), L = shallowRef(I);
+  watchEffect(() => {
+    if (!z.value)
+      return;
+    const e2 = m || !b.value ? null : De(b.value.scrollTop, I), r = o().keyField, s = k.value, u = v.sizes, c = C.value, f$1 = c.length;
+    let S = I.length !== f$1, h = I.length !== f$1;
+    for (let _ = 0; _ < f$1; _++) {
+      const M = c[_], K = s ? _ : f(M, _, r);
+      let B = u[K];
+      typeof B > "u" && !a[K] && (B = 0);
+      let P = I[_];
+      if (!P) {
+        P = shallowReactive({
+          item: M,
+          id: K,
+          size: B
+        }), I[_] = P, S = true, h = true;
+        continue;
+      }
+      P.item !== M && (P.item = M, S = true, h = true), P.id !== K && (P.id = K, S = true, h = true), P.size !== B && (P.size = B, S = true);
+    }
+    I.length !== f$1 && (I.length = f$1, S = true, h = true), S && (y = e2, oe.value++, h ? L.value = I.slice() : triggerRef(L));
+  });
+  function De(e2, t) {
+    if (!t.length)
+      return null;
+    const r = o().minItemSize;
+    let s = 0, u = 0, c = t[0].id;
+    for (const f2 of t) {
+      const S = f2.size || r, h = s + S;
+      if (u = s, c = f2.id, e2 < h)
+        return {
+          key: f2.id,
+          offset: e2 - s
+        };
+      s = h;
+    }
+    return {
+      key: c,
+      offset: Math.max(0, e2 - u)
+    };
+  }
+  const J = o();
+  D = Be(C.value, k.value ? null : J.keyField), J.cache && (v.sizes = bn(J.cache, C.value, k.value ? null : J.keyField));
+  function Oe() {
+    var e2, t;
+    (t = (e2 = o()).onHidden) == null || t.call(e2);
+  }
+  function Pe(e2, t, r, s) {
+    var u, c;
+    (c = (u = o()).onUpdate) == null || c.call(u, e2, t, r, s);
+  }
+  const Ce = reactive({
+    get enabled() {
+      return z.value;
+    },
+    get items() {
+      return L.value;
+    },
+    get keyField() {
+      return "id";
+    },
+    get direction() {
+      return E.value;
+    },
+    get itemSize() {
+      return null;
+    },
+    get gridItems() {
+    },
+    get itemSecondarySize() {
+    },
+    get minItemSize() {
+      return o().minItemSize;
+    },
+    get sizeField() {
+      return "size";
+    },
+    get typeField() {
+      return "type";
+    },
+    get buffer() {
+      var _a;
+      return (_a = o().buffer) != null ? _a : 200;
+    },
+    get pageMode() {
+      var _a;
+      return (_a = o().pageMode) != null ? _a : false;
+    },
+    get shift() {
+      return false;
+    },
+    get cache() {
+      return o().cache;
+    },
+    get prerender() {
+      var _a;
+      return (_a = o().prerender) != null ? _a : 0;
+    },
+    get emitUpdate() {
+      var _a;
+      return (_a = o().emitUpdate) != null ? _a : false;
+    },
+    get disableTransform() {
+      var _a;
+      return (_a = o().disableTransform) != null ? _a : false;
+    },
+    get flowMode() {
+      var _a;
+      return (_a = o().flowMode) != null ? _a : false;
+    },
+    get hiddenPosition() {
+      return o().hiddenPosition;
+    },
+    get updateInterval() {
+      var _a;
+      return (_a = o().updateInterval) != null ? _a : 0;
+    },
+    get el() {
+      return b.value;
+    },
+    get before() {
+      return Me.value;
+    },
+    get after() {
+      return Ae.value;
+    },
+    get scrollParent() {
+      return o().scrollParent;
+    },
+    get onResize() {
+      return ce;
+    },
+    get onVisible() {
+      return ue;
+    },
+    get onHidden() {
+      return Oe;
+    },
+    get onUpdate() {
+      return Pe;
+    }
+  });
+  function ce() {
+    var e2, t;
+    N(), (t = (e2 = o()).onResize) == null || t.call(e2);
+  }
+  function ue() {
+    var e2, t;
+    d.emit("vscroll:update", { force: false }), (t = (e2 = o()).onVisible) == null || t.call(e2);
+  }
+  const F = qn(
+    Ce
+  ), O = /* @__PURE__ */ new WeakMap(), ae = /* @__PURE__ */ new WeakMap(), ee = shallowRef([]);
+  function Ee(e2) {
+    var _a, _b;
+    const t = o();
+    return Tn(Q(e2, O), {
+      direction: E.value,
+      mode: Mn({
+        direction: E.value,
+        disableTransform: (_a = t.disableTransform) != null ? _a : false,
+        flowMode: (_b = t.flowMode) != null ? _b : false
+      })
+    });
+  }
+  function fe(e2) {
+    let t = ae.get(e2);
+    return t || (t = it(e2), ae.set(e2, t), O.set(t, e2)), t;
+  }
+  watchEffect(() => {
+    const e2 = F.pool.value, t = e2.length, r = ee.value;
+    let s = r.length !== t;
+    for (let u = 0; u < t; u++) {
+      const c = fe(e2[u]);
+      r[u] !== c && (r[u] = c, s = true);
+    }
+    r.length !== t && (r.length = t, s = true), s && triggerRef(ee);
+  });
+  const Ke = computed(
+    () => F.visiblePool.value.map(fe)
+  ), V = /* @__PURE__ */ new WeakMap();
+  function te() {
+    R != null && (cancelAnimationFrame(R), g.delete(R), R = null);
+  }
+  function T() {
+    te(), m = null;
+  }
+  function Be$1() {
+    m == null || R != null || (R = $(() => {
+      R = null, ne();
+    }));
+  }
+  function We() {
+    const e2 = b.value;
+    if (!e2)
+      return null;
+    const t = e2.getBoundingClientRect();
+    let r = null;
+    for (const [s, u] of H.entries()) {
+      if (!u.active || getComputedStyle(s).visibility === "hidden")
+        continue;
+      const c = s.getBoundingClientRect();
+      if (c.bottom <= t.top || c.top >= t.bottom)
+        continue;
+      const f2 = Math.max(c.top, t.top) - t.top;
+      (!r || f2 < r.score) && (r = {
+        key: u.id,
+        offset: c.top - t.top,
+        score: f2
+      });
+    }
+    return r;
+  }
+  function Ue(e2) {
+    var _a, _b;
+    const t = b.value;
+    if (!t) {
+      T();
+      return;
+    }
+    const r = t.scrollTop, s = Math.min(F.findItemIndex(r), e2.length - 1), u = e2[s];
+    if (u == null) {
+      T();
+      return;
+    }
+    const c = We();
+    m = {
+      logicalKey: u,
+      logicalOffset: r - F.getItemOffset(s),
+      pendingKeys: /* @__PURE__ */ new Set(),
+      stableFrames: 0,
+      visualKey: (_a = c == null ? void 0 : c.key) != null ? _a : null,
+      visualOffset: (_b = c == null ? void 0 : c.offset) != null ? _b : 0
+    };
+  }
+  function de(e2) {
+    const t = b.value;
+    return !t || Math.abs(t.scrollTop - e2) < 0.5 ? false : (x = true, t.scrollTop = e2, F.updateVisibleItems(true), t.dispatchEvent(new Event("scroll")), $(() => {
+      x = false;
+    }), true);
+  }
+  function ne() {
+    const e2 = m, t = b.value;
+    if (!e2 || !t)
+      return;
+    const r = L.value.findIndex((f2) => f2.id === e2.logicalKey);
+    if (r === -1) {
+      T();
+      return;
+    }
+    let s = false;
+    const u = F.getItemOffset(r) + e2.logicalOffset;
+    if (s = de(u) || s, !s && e2.visualKey != null)
+      for (const [f2, S] of H.entries()) {
+        if (!S.active || S.id !== e2.visualKey || getComputedStyle(f2).visibility === "hidden")
+          continue;
+        const h = f2.getBoundingClientRect().top - t.getBoundingClientRect().top - e2.visualOffset;
+        s = de(t.scrollTop + h) || s;
+        break;
+      }
+    let c = true;
+    for (const f2 of e2.pendingKeys)
+      if (!(typeof v.sizes[f2] == "number" && v.sizes[f2] > 0)) {
+        c = false;
+        break;
+      }
+    if (!s && c) {
+      if (e2.stableFrames++, e2.stableFrames >= 2) {
+        T();
+        return;
+      }
+    } else
+      e2.stableFrames = 0;
+    Be$1();
+  }
+  function me(e2, t, r, s) {
+    const u = effectScope(), c = shallowRef(t), f2 = shallowReactive(__spreadValues({}, r)), S = shallowReactive({
+      onResize: r.onResize
+    }), h = shallowRef(e2), _ = u.run(() => (watch(() => we(
+      c.value,
+      f2,
+      o().keyField,
+      v.simpleArray,
+      v.active,
+      O
+    ), () => {
+      const M = h.value;
+      if (M) {
+        const K = we(
+          c.value,
+          f2,
+          o().keyField,
+          v.simpleArray,
+          v.active,
+          O
+        ), B = K.id;
+        B != null && H.set(M, {
+          active: K.active,
+          id: B
+        });
+      }
+    }, {
+      immediate: true
+    }), watch(() => {
+      var _a;
+      return lt(
+        c.value,
+        E.value,
+        (_a = o().flowMode) != null ? _a : false,
+        O
+      );
+    }, () => {
+      var _a, _b;
+      const M = h.value;
+      M && ze(
+        M,
+        c.value,
+        E.value,
+        (_a = o().disableTransform) != null ? _a : false,
+        (_b = o().flowMode) != null ? _b : false,
+        s,
+        O
+      );
+    }, {
+      immediate: true
+    }), q(
+      f2,
+      h,
+      Z,
+      S
+    )));
+    _.mount(), V.set(e2, {
+      binding: c,
+      scope: u,
+      options: f2,
+      callbacks: S,
+      el: h,
+      controller: _,
+      restoreStyles: s
+    });
+  }
+  const $e = {
+    mounted(e2, t) {
+      if (!z.value)
+        return;
+      const r = Se(e2);
+      me(e2, t.value, Re(t.value, O), r);
+    },
+    updated(e2, t) {
+      var _a, _b;
+      if (!z.value)
+        return;
+      const r = V.get(e2), s = Re(t.value, O);
+      if (!r) {
+        const c = Se(e2);
+        me(e2, t.value, s, c);
+        return;
+      }
+      const u = r.binding.value !== t.value;
+      u && (r.binding.value = t.value), ot(r.options, s), ct(r.callbacks, s), r.el.value !== e2 && (r.el.value = e2), u && ze(
+        e2,
+        t.value,
+        E.value,
+        (_a = o().disableTransform) != null ? _a : false,
+        (_b = o().flowMode) != null ? _b : false,
+        r.restoreStyles,
+        O
+      );
+    },
+    unmounted(e2) {
+      const t = V.get(e2);
+      t && (t.controller.unmount(), t.scope.stop(), _e(e2, t.restoreStyles), H.delete(e2), V.delete(e2));
+    }
+  };
+  function N(e2 = false) {
+    z.value && ((e2 || k.value) && (v.sizes = {}), d.emit("vscroll:update", { force: true }));
+  }
+  function He(e2, t) {
+    F.scrollToItem(e2, t);
+  }
+  function ve(e2) {
+    const t = o();
+    return v.sizes = bn(e2, C.value, k.value ? null : t.keyField), F.restoreCache(e2);
+  }
+  function Le(e$1, t) {
+    const r = o(), s = t != null ? t : C.value.indexOf(e$1), u = k.value ? s : e(e$1, s >= 0 ? s : t, r.keyField);
+    return v.sizes[u] || 0;
+  }
+  function Ne() {
+    if (!z.value)
+      return;
+    const e2 = b.value;
+    e2 && (p || (p = true, nextTick(() => {
+      e2.scrollTop = e2.scrollHeight + 5e3;
+      const t = () => {
+        e2.scrollTop = e2.scrollHeight + 5e3, $(() => {
+          e2.scrollTop = e2.scrollHeight + 5e3, l === 0 ? p = false : $(t);
+        });
+      };
+      $(t);
+    })));
+  }
+  function q$1() {
+    m && !x && T();
+  }
+  return watch(() => C.value.slice(), (e2, t) => {
+    if (!z.value)
+      return;
+    const r = o(), s = k.value ? null : r.keyField, u = Be(e2, s);
+    if (r.shift) {
+      const c = t ? Be(t, s) : D, f2 = zn(c, u);
+      f2 > 0 ? (Ue(c), m && (m.pendingKeys = new Set(u.slice(0, f2)), m.stableFrames = 0, nextTick(() => {
+        m && ne();
+      }))) : T();
+    } else
+      T();
+    D = u, N();
+  }, { flush: "sync" }), watch(() => o().cache, (e2) => {
+    z.value && e2 && ve(e2);
+  }), watch(() => o().keyField, (e2) => {
+    z.value && (v.keyField = e2, D = Be(C.value, k.value ? null : e2), T(), N(true));
+  }, { flush: "sync" }), watch(k, (e2) => {
+    v.simpleArray = e2;
+  }, { immediate: true }), watch(() => o().direction, () => {
+    z.value && (T(), N(true));
+  }), watch(b, (e2, t) => {
+    t == null || t.removeEventListener("scroll", q$1), z.value && (e2 == null || e2.addEventListener("scroll", q$1));
+  }, {
+    immediate: true
+  }), watch(z, (e2) => {
+    const t = b.value;
+    e2 ? (t == null || t.addEventListener("scroll", q$1), N()) : (t == null || t.removeEventListener("scroll", q$1), te(), le(), T());
+  }), watch(oe, () => {
+    if (!z.value)
+      return;
+    const e2 = b.value;
+    if (!e2)
+      return;
+    if (m) {
+      ne();
+      return;
+    }
+    const t = y;
+    if (y = null, !t)
+      return;
+    const r = L.value.findIndex((c) => c.id === t.key);
+    if (r === -1)
+      return;
+    const s = F.getItemOffset(r) + t.offset;
+    s - e2.scrollTop !== 0 && (e2.scrollTop = s);
+  }, { flush: "post" }), onActivated(() => {
+    v.active = true;
+  }), onDeactivated(() => {
+    v.active = false;
+  }), onUnmounted(() => {
+    var e2;
+    te(), le(), (e2 = b.value) == null || e2.removeEventListener("scroll", q$1), d.clear();
+  }), __spreadProps(__spreadValues({
+    vscrollData: v,
+    itemsWithSize: L,
+    resizeObserver: w,
+    measurementContext: Z,
+    vDynamicScrollerItem: $e
+  }, F), {
+    pool: ee,
+    visiblePool: Ke,
+    simpleArray: k,
+    forceUpdate: N,
+    scrollToItem: He,
+    restoreCache: ve,
+    getItemSize: Le,
+    getViewStyle: Ee,
+    scrollToBottom: Ne,
+    onScrollerResize: ce,
+    onScrollerVisible: ue
+  });
+}
+export {
+  vt as useDynamicScroller
+};
+//# sourceMappingURL=index244.mjs.map