vane-waterfall 2.0.1 → 2.0.2

package/dist/chunks/WaterfallCore-EdAZuWAY.js

@@ -0,0 +1,695 @@
+import { jsxs as de, jsx as Lt } from "react/jsx-runtime";
+import ye, { forwardRef as pe, useRef as l, useMemo as bt, useCallback as L, useState as Ht, useLayoutEffect as be, useEffect as Ct, useImperativeHandle as He } from "react";
+function we(r = 0) {
+  return typeof r == "number" ? { top: r, right: r, bottom: r, left: r } : {
+    top: r.top ?? 0,
+    right: r.right ?? 0,
+    bottom: r.bottom ?? 0,
+    left: r.left ?? 0
+  };
+}
+function Re(r, a, u) {
+  return typeof r == "number" && Number.isFinite(r) && r > 0 ? r : a && a > 0 ? a : u && u > 0 ? u : 0;
+}
+function Me(r) {
+  const {
+    heights: a,
+    columnGap: u,
+    rowGap: o,
+    alignmentMode: b = "shortest",
+    estimateHeight: R,
+    minItemHeight: g,
+    hooks: M
+  } = r, f = we(r.padding), H = r.containerWidth, T = M?.calculateColumns?.(r.columns), c = Math.max(
+    1,
+    Math.round(
+      typeof T == "number" && Number.isFinite(T) ? T : r.columns
+    )
+  ), $ = (H - f.left - f.right - u * (c - 1)) / c, F = M?.calculateColumnWidth?.(
+    $,
+    c,
+    H
+  ), z = typeof F == "number" && Number.isFinite(F) ? F : $, I = Array(c).fill(f.top), G = Array(c).fill(0), x = /* @__PURE__ */ new Map();
+  let nt = 0;
+  if (a.length === 0)
+    return {
+      columns: c,
+      columnWidth: z,
+      padding: f,
+      columnHeights: I,
+      totalHeight: f.top + f.bottom,
+      positions: x,
+      estimatedCount: 0
+    };
+  for (let V = 0; V < a.length; V++) {
+    const D = a[V], rt = Re(D, R, g);
+    if (rt === 0) continue;
+    typeof D == "number" && D > 0 || (nt += 1);
+    let S = 0;
+    if (b === "sequential")
+      S = V % c;
+    else if (b === "balanced") {
+      let W = G[0];
+      for (let v = 1; v < c; v++)
+        G[v] < W && (W = G[v], S = v);
+    } else {
+      let W = I[0];
+      for (let v = 1; v < I.length; v++)
+        I[v] < W && (W = I[v], S = v);
+    }
+    let A = {
+      x: f.left + S * (z + u),
+      y: I[S],
+      width: z,
+      height: rt,
+      column: S,
+      row: Math.floor(V / c)
+    };
+    const U = M?.calculateItemPosition?.(V, rt, A);
+    if (U) {
+      const W = { ...A, ...U };
+      U.column !== void 0 && U.x === void 0 && (W.x = f.left + Math.min(Math.max(0, W.column), c - 1) * (z + u)), A = W;
+    }
+    x.set(V, A);
+    const ot = Math.min(
+      Math.max(0, A.column),
+      I.length - 1
+    );
+    I[ot] = A.y + A.height + o, G[ot] += 1;
+  }
+  return {
+    columns: c,
+    columnWidth: z,
+    padding: f,
+    columnHeights: I,
+    totalHeight: Math.max(...I) + f.bottom,
+    positions: x,
+    estimatedCount: nt
+  };
+}
+function Ie(r, a, u = "start", o = 0) {
+  let b = r.y + o;
+  return u === "center" ? b -= a / 2 - r.height / 2 : u === "end" && (b -= a - r.height), Math.max(0, b);
+}
+const ve = 8;
+function Te(r, a, u = 0.5) {
+  const o = [];
+  for (const g of r)
+    Number.isFinite(g) && g > 0 && o.push(g);
+  if (o.length < ve) return a;
+  o.sort((g, M) => g - M);
+  const b = Math.min(1, Math.max(0, u)), R = Math.min(o.length - 1, Math.round(b * (o.length - 1)));
+  return Math.max(1, Math.ceil(o[R]));
+}
+function Se(r, a, u, o, b = 1) {
+  if (a <= 0) return { start: 0, end: -1, hiddenCount: 0 };
+  if (r.size === 0) {
+    const c = Math.max(1, Math.ceil(o / 240) + 2);
+    return { start: 0, end: Math.min(a - 1, c - 1), hiddenCount: 0 };
+  }
+  const R = Math.max(0, o * b), g = u - R, M = u + Math.max(o, 1) + R;
+  let f = Number.POSITIVE_INFINITY, H = -1;
+  if (r.forEach((c, N) => {
+    const $ = c.y;
+    c.y + c.height > g && $ < M && (N < f && (f = N), N > H && (H = N));
+  }), H < 0) {
+    let c = 0, N = Number.POSITIVE_INFINITY;
+    r.forEach((F, z) => {
+      const I = Math.abs(F.y - u);
+      I < N && (N = I, c = z);
+    });
+    const $ = Math.max(1, Math.ceil(o / 240) + 2);
+    f = Math.max(0, c - $), H = Math.min(a - 1, c + $);
+  }
+  f = Math.max(0, f), H = Math.min(a - 1, H), H < f && (H = f);
+  const T = H - f + 1;
+  return { start: f, end: H, hiddenCount: Math.max(0, a - T) };
+}
+function We(r) {
+  return r ? r === !0 ? {
+    overscan: 1,
+    estimateHeight: 240,
+    dynamicHeights: !0,
+    adaptiveEstimate: !0,
+    estimateQuantile: 0.5
+  } : {
+    overscan: r.overscan ?? 1,
+    estimateHeight: r.estimateHeight ?? 240,
+    dynamicHeights: r.dynamicHeights ?? !0,
+    adaptiveEstimate: r.adaptiveEstimate ?? !0,
+    estimateQuantile: r.estimateQuantile ?? 0.5
+  } : null;
+}
+function Zt(r, a, u, o) {
+  const b = a.y, R = a.y + a.height, g = u + o, M = Math.max(
+    0,
+    Math.min(g, R) - Math.max(u, b)
+  );
+  return {
+    index: r,
+    isVisible: M > 0,
+    visibleRatio: a.height > 0 ? Math.min(1, M / a.height) : 0,
+    isAboveViewport: R <= u,
+    isBelowViewport: b >= g
+  };
+}
+const Ee = ye.memo(function({
+  index: a,
+  item: u,
+  position: o,
+  useTransform: b,
+  itemStyle: R,
+  itemClassName: g,
+  renderItem: M,
+  onClick: f,
+  itemRef: H
+}) {
+  const T = o ? b ? {
+    position: "absolute",
+    transform: `translate(${o.x}px, ${o.y}px)`,
+    width: o.width,
+    boxSizing: "border-box"
+  } : {
+    position: "absolute",
+    left: o.x,
+    top: o.y,
+    width: o.width,
+    boxSizing: "border-box"
+  } : { position: "absolute", opacity: 0, pointerEvents: "none" };
+  return /* @__PURE__ */ Lt(
+    "div",
+    {
+      ref: H,
+      style: { ...T, ...R },
+      className: g,
+      onClick: f ? (c) => f(a, u, c) : void 0,
+      "data-index": a,
+      "data-column": o?.column,
+      children: M(u, a)
+    }
+  );
+}), Ve = pe(
+  function(a, u) {
+    const {
+      items: o = [],
+      renderItem: b,
+      keyExtractor: R = (t, e) => e,
+      columns: g = 3,
+      gap: M = 16,
+      rowGap: f,
+      columnGap: H,
+      alignmentMode: T = "shortest",
+      padding: c = 0,
+      containerStyle: N,
+      containerClassName: $,
+      itemStyle: F,
+      itemClassName: z,
+      useTransform: I = !0,
+      throttleDelay: G = 16,
+      debounceDelay: x = 150,
+      reachBottomOffset: nt = 100,
+      minItemHeight: V = 48,
+      scrollAnchor: D = !0,
+      virtualize: rt,
+      layoutHooks: S,
+      onMount: A,
+      onUnmount: U,
+      onBeforeLayout: ot,
+      onLayout: W,
+      onLayoutComplete: v,
+      onItemMount: te,
+      onItemUnmount: ee,
+      onItemEnterViewport: wt,
+      onItemLeaveViewport: Rt,
+      onScroll: Nt,
+      onResize: Vt,
+      onReachBottom: $t,
+      onItemClick: ne,
+      children: re,
+      containerRefExternal: oe,
+      itemRefsExternal: ce,
+      debug: Mt = !1
+    } = a, ie = l(null), y = oe ?? ie, se = l(/* @__PURE__ */ new Map()), O = ce ?? se, C = l(/* @__PURE__ */ new Map()), j = l(/* @__PURE__ */ new Map()), ut = l(null), ct = l(), it = l(), J = l(null), K = l(null), zt = l(0), ft = l(!1), st = l(0), It = l(!1), At = l(""), kt = l(void 0), ht = l(async () => {
+    }), lt = l(!1), at = l(!1), mt = l(/* @__PURE__ */ new Set()), X = l(o);
+    X.current = o;
+    const k = l(/* @__PURE__ */ new Map()), Bt = l(null), vt = l(0), Ft = l(R);
+    Ft.current = R;
+    const xt = l($t);
+    xt.current = $t;
+    const gt = f ?? M, Z = H ?? M, Ot = typeof c == "number" ? c : c?.top ?? 0, Pt = typeof c == "number" ? c : c?.right ?? 0, _t = typeof c == "number" ? c : c?.bottom ?? 0, Gt = typeof c == "number" ? c : c?.left ?? 0, q = bt(
+      () => ({ top: Ot, right: Pt, bottom: _t, left: Gt }),
+      [Ot, Pt, _t, Gt]
+    ), E = L((t) => {
+      const e = X.current[t];
+      if (e === void 0) return `#${t}`;
+      try {
+        return String(Ft.current(e, t));
+      } catch {
+        return `#${t}`;
+      }
+    }, []), qt = L(() => {
+      const t = X.current;
+      let e = String(t.length);
+      for (let n = 0; n < t.length; n++) e += `|${E(n)}`;
+      return e;
+    }, [E]), Qt = JSON.stringify(rt ?? null), d = bt(
+      () => We(JSON.parse(Qt) ?? void 0),
+      [Qt]
+    ), [Q, le] = Ht(() => ({
+      columns: g,
+      columnWidth: 0,
+      gap: Z,
+      columnHeights: Array(g).fill(0),
+      totalHeight: 0,
+      containerWidth: 0,
+      containerHeight: 0
+    })), [dt, ae] = Ht(
+      () => /* @__PURE__ */ new Map()
+    ), [P, Yt] = Ht({
+      scrollTop: 0,
+      scrollLeft: 0,
+      scrollHeight: 0,
+      scrollWidth: 0,
+      clientHeight: 0,
+      clientWidth: 0,
+      isScrolling: !1,
+      direction: null
+    }), [, ue] = Ht({});
+    k.current = dt;
+    const Tt = l(Q), Dt = L(
+      (t) => {
+        const e = k.current;
+        if (e.size === 0) return null;
+        const n = t.scrollTop;
+        if (n <= 0) return null;
+        let i = -1, h = Number.POSITIVE_INFINITY, w = -1, s = Number.NEGATIVE_INFINITY;
+        e.forEach((p, B) => {
+          p.y >= n && p.y < h && (h = p.y, i = B), p.y <= n && p.y + p.height > n && p.y > s && (s = p.y, w = B);
+        });
+        const m = i >= 0 ? i : w, _ = e.get(m);
+        return _ ? { index: m, offset: _.y - n } : null;
+      },
+      []
+    ), Ut = l(""), tt = l(null), yt = L(() => {
+      const t = xt.current;
+      if (!t) return;
+      const e = y.current;
+      if (!e) return;
+      const { scrollTop: n, scrollHeight: i, clientHeight: h } = e, w = i - (n + h);
+      if (w >= nt) return;
+      const s = `${n}|${i}|${h}`;
+      s !== Ut.current && (Ut.current = s, t(w));
+    }, [y, nt]), jt = L(() => {
+      tt.current == null && (tt.current = window.setTimeout(() => {
+        tt.current = null, yt();
+      }, 0));
+    }, [yt]), et = L(async () => {
+      const t = y.current;
+      if (!t) return;
+      const e = `${g}|${Z}|${gt}|${q.top},${q.right},${q.bottom},${q.left}|${T}|${d?.estimateHeight ?? ""}|${d?.adaptiveEstimate ?? ""}|${d?.estimateQuantile ?? ""}`;
+      if (ft.current) {
+        (e !== At.current || S !== kt.current) && (It.current = !0);
+        return;
+      }
+      ft.current = !0, At.current = e, kt.current = S, at.current = !1;
+      const n = Dt(t);
+      try {
+        if (await ot?.() === !1) return;
+        Mt && console.time("[WaterfallCore] layout"), W?.();
+        const h = t.clientWidth, w = X.current.map((p, B) => {
+          const Et = O.current.get(B)?.offsetHeight ?? 0;
+          return Et > 0 ? (C.current.set(E(B), Et), Et) : C.current.get(E(B)) ?? 0;
+        });
+        let s;
+        if (d)
+          if (d.adaptiveEstimate === !1)
+            s = d.estimateHeight;
+          else {
+            const p = Te(
+              C.current.values(),
+              d.estimateHeight ?? 240,
+              d.estimateQuantile
+            );
+            Math.abs(p - st.current) > 8 && (st.current = p), s = st.current || p;
+          }
+        const m = Me({
+          heights: w,
+          columns: g,
+          containerWidth: h,
+          columnGap: Z,
+          rowGap: gt,
+          padding: q,
+          alignmentMode: T,
+          estimateHeight: s,
+          minItemHeight: V,
+          hooks: S
+        }), _ = {
+          columns: m.columns,
+          columnWidth: m.columnWidth,
+          gap: Z,
+          columnHeights: m.columnHeights,
+          totalHeight: m.totalHeight,
+          containerWidth: h,
+          containerHeight: t.clientHeight
+        };
+        if (Tt.current = _, k.current = m.positions, le(_), ae(m.positions), lt.current = !0, Mt && (console.timeEnd("[WaterfallCore] layout"), m.estimatedCount > 0 && console.debug(
+          `[WaterfallCore] ${m.estimatedCount} 项按估值占位（estimateHeight=${s}）`
+        )), v?.(), n && D) {
+          const p = m.positions.get(n.index);
+          if (p) {
+            const B = p.y - n.offset - t.scrollTop;
+            Math.abs(B) >= 1 && (vt.current += B);
+          }
+        }
+        jt();
+      } catch (i) {
+        console.warn("[vane-waterfall] 布局过程出错，本次布局已跳过", i);
+      } finally {
+        ft.current = !1, It.current && (It.current = !1, ht.current());
+      }
+    }, [
+      g,
+      Z,
+      gt,
+      q,
+      T,
+      d?.estimateHeight,
+      S,
+      ot,
+      W,
+      v,
+      Mt,
+      V,
+      D,
+      y,
+      O,
+      E,
+      Dt,
+      jt
+    ]);
+    be(() => {
+      const t = vt.current;
+      if (!t) return;
+      vt.current = 0;
+      const e = y.current;
+      e && (e.scrollTop += t);
+    }), ht.current = et;
+    const pt = L(() => {
+      it.current && window.clearTimeout(it.current), it.current = window.setTimeout(() => {
+        ht.current();
+      }, x);
+    }, [x]), Jt = L(() => {
+      J.current == null && (J.current = requestAnimationFrame(() => {
+        J.current = null, ht.current();
+      }));
+    }, []), Kt = L((t) => {
+      K.current == null && (K.current = requestAnimationFrame(() => {
+        K.current = null;
+        const e = y.current;
+        e && Yt((n) => {
+          const i = e.scrollTop, h = e.scrollLeft, w = i > n.scrollTop ? "down" : i < n.scrollTop ? "up" : h > n.scrollLeft ? "right" : h < n.scrollLeft ? "left" : n.direction, s = {
+            scrollTop: i,
+            scrollLeft: h,
+            scrollHeight: e.scrollHeight,
+            scrollWidth: e.scrollWidth,
+            clientHeight: e.clientHeight,
+            clientWidth: e.clientWidth,
+            isScrolling: t,
+            direction: w
+          };
+          return n.scrollTop === s.scrollTop && n.scrollLeft === s.scrollLeft && n.scrollHeight === s.scrollHeight && n.clientHeight === s.clientHeight && n.isScrolling === s.isScrolling ? n : s;
+        });
+      }));
+    }, [y]), fe = L(() => {
+      const t = y.current;
+      if (!t) return;
+      const e = Date.now();
+      Kt(!0);
+      const n = t.scrollTop, i = t.clientHeight;
+      if (Nt?.(n, t.scrollLeft), e - zt.current >= G && (zt.current = e, yt(), wt || Rt)) {
+        const h = k.current, w = /* @__PURE__ */ new Set();
+        h.forEach((s, m) => {
+          Math.max(
+            0,
+            Math.min(n + i, s.y + s.height) - Math.max(n, s.y)
+          ) > 0 && (w.add(m), mt.current.has(m) || wt?.(
+            m,
+            Zt(m, s, n, i)
+          ));
+        }), mt.current.forEach((s) => {
+          if (w.has(s)) return;
+          const m = h.get(s);
+          m && Rt?.(
+            s,
+            Zt(s, m, n, i)
+          );
+        }), mt.current = w;
+      }
+      ct.current && window.clearTimeout(ct.current), ct.current = window.setTimeout(() => {
+        Yt((h) => ({ ...h, isScrolling: !1 }));
+      }, x);
+    }, [
+      Kt,
+      Nt,
+      wt,
+      Rt,
+      G,
+      x,
+      yt
+    ]), he = L(() => {
+      const t = y.current;
+      t && (Vt?.(t.clientWidth, t.clientHeight), pt());
+    }, [Vt, pt, y]);
+    Ct(() => {
+      A?.(), lt.current || et();
+      const t = y.current;
+      return t && typeof ResizeObserver < "u" && (ut.current = new ResizeObserver(he), ut.current.observe(t)), () => {
+        U?.(), ut.current?.disconnect(), ut.current = null, j.current.forEach((e) => {
+          try {
+            e.disconnect();
+          } catch {
+          }
+        }), j.current.clear(), ct.current && window.clearTimeout(ct.current), it.current && window.clearTimeout(it.current), tt.current != null && (window.clearTimeout(tt.current), tt.current = null), K.current != null && (cancelAnimationFrame(K.current), K.current = null), J.current != null && (cancelAnimationFrame(J.current), J.current = null);
+      };
+    }, []);
+    const St = l(/* @__PURE__ */ new Map());
+    Ct(() => {
+      const t = qt();
+      if (t === Bt.current) return;
+      Bt.current = t, lt.current = !1, at.current = !1, St.current.clear();
+      const e = /* @__PURE__ */ new Set();
+      for (let i = 0; i < X.current.length; i++) e.add(E(i));
+      let n = 0;
+      C.current.forEach((i, h) => {
+        e.has(h) ? n += 1 : C.current.delete(h);
+      }), n === 0 && (st.current = 0), pt();
+    }, [o, pt, qt, E]), Ct(() => {
+      lt.current = !1, at.current = !1, et();
+    }, [
+      g,
+      Z,
+      gt,
+      q,
+      T,
+      d?.estimateHeight,
+      d?.adaptiveEstimate,
+      d?.estimateQuantile,
+      S
+    ]);
+    const Xt = l(
+      () => {
+      }
+    );
+    Xt.current = (t, e) => {
+      if (e) {
+        O.current.set(t, e);
+        const n = E(t), i = e.offsetHeight;
+        if (i > 0 && C.current.set(n, i), (d ? d.dynamicHeights !== !1 : !0) && !j.current.has(t) && typeof ResizeObserver < "u") {
+          const w = new ResizeObserver(() => {
+            const s = e.offsetHeight;
+            if (s <= 0) return;
+            C.current.set(E(t), s);
+            const m = k.current.get(t), _ = m ? Math.abs(m.height - s) > 0.5 : !1, p = St.current.get(t) === s;
+            m ? _ && !p && (St.current.set(t, s), Jt()) : Jt();
+          });
+          try {
+            w.observe(e), j.current.set(t, w);
+          } catch {
+          }
+        }
+        te?.(t, e), lt.current && !k.current.has(t) && !ft.current && !at.current && (at.current = !0, requestAnimationFrame(() => void et()));
+      } else {
+        O.current.delete(t), Wt.current.delete(t);
+        const n = j.current.get(t);
+        if (n) {
+          try {
+            n.disconnect();
+          } catch {
+          }
+          j.current.delete(t);
+        }
+        ee?.(t);
+      }
+    };
+    const Wt = l(
+      /* @__PURE__ */ new Map()
+    ), me = (t) => {
+      let e = Wt.current.get(t);
+      return e || (e = (n) => Xt.current(t, n), Wt.current.set(t, e)), e;
+    }, Y = bt(
+      () => d ? Se(
+        dt,
+        o.length,
+        P.scrollTop,
+        P.clientHeight || Q.containerHeight || 600,
+        d.overscan
+      ) : { start: 0, end: Math.max(0, o.length - 1), hiddenCount: 0 },
+      [
+        d,
+        dt,
+        o.length,
+        P.scrollTop,
+        P.clientHeight,
+        Q.containerHeight
+      ]
+    );
+    He(
+      u,
+      () => ({
+        relayout: () => {
+          C.current.clear(), st.current = 0, X.current.forEach((t, e) => {
+            const n = O.current.get(e);
+            if (!n) return;
+            const i = n.offsetHeight;
+            i > 0 && C.current.set(E(e), i);
+          }), et();
+        },
+        scrollToItem: (t, e = {}) => {
+          const n = y.current, i = k.current.get(t);
+          !n || !i || n.scrollTo({
+            top: Ie(
+              i,
+              n.clientHeight,
+              e.block ?? "start",
+              e.offset ?? 0
+            ),
+            behavior: e.behavior ?? "auto"
+          });
+        },
+        scrollToTop: (t = {}) => {
+          y.current?.scrollTo({
+            top: t.offset ?? 0,
+            behavior: t.behavior ?? "auto"
+          });
+        },
+        scrollToBottom: (t = {}) => {
+          const e = y.current;
+          e && e.scrollTo({
+            top: e.scrollHeight - e.clientHeight + (t.offset ?? 0),
+            behavior: t.behavior ?? "auto"
+          });
+        },
+        getItemPosition: (t) => k.current.get(t) ?? null,
+        getAllItemPositions: () => k.current,
+        getColumnHeights: () => Tt.current.columnHeights,
+        getLayoutInfo: () => Tt.current,
+        getViewportInfo: () => {
+          const t = y.current;
+          return t ? {
+            scrollTop: t.scrollTop,
+            scrollLeft: t.scrollLeft,
+            scrollHeight: t.scrollHeight,
+            scrollWidth: t.scrollWidth,
+            clientHeight: t.clientHeight,
+            clientWidth: t.clientWidth,
+            isScrolling: P.isScrolling,
+            direction: P.direction
+          } : P;
+        },
+        getVisibleRange: () => ({ start: Y.start, end: Y.end }),
+        getVisibleItems: () => new Set(mt.current),
+        forceUpdate: () => ue({}),
+        getContainer: () => y.current,
+        getItemElement: (t) => O.current.get(t) ?? null,
+        measureItem: async (t) => {
+          const e = O.current.get(t), n = E(t);
+          if (e) {
+            const h = { width: e.offsetWidth, height: e.offsetHeight };
+            return h.height > 0 && C.current.set(n, h.height), h;
+          }
+          const i = C.current.get(n);
+          return i ? { width: Q.columnWidth, height: i } : { width: Q.columnWidth, height: d?.estimateHeight ?? 0 };
+        }
+      }),
+      [
+        et,
+        Q,
+        P,
+        Y,
+        y,
+        O,
+        d?.estimateHeight,
+        E
+      ]
+    );
+    const ge = bt(() => {
+      if (!d) return o.map((e, n) => n);
+      const t = [];
+      for (let e = Y.start; e <= Y.end; e++) t.push(e);
+      return t;
+    }, [d, o, Y.start, Y.end]);
+    return /* @__PURE__ */ de(
+      "div",
+      {
+        ref: y,
+        style: {
+          position: "relative",
+          overflowX: "hidden",
+          overflowY: "auto",
+          ...N
+        },
+        className: $,
+        onScroll: fe,
+        "data-vane-waterfall": "",
+        children: [
+          re,
+          /* @__PURE__ */ Lt(
+            "div",
+            {
+              style: {
+                position: "relative",
+                width: "100%",
+                height: Q.totalHeight,
+                minWidth: 0
+              },
+              children: ge.map((t) => {
+                const e = o[t];
+                return e === void 0 ? null : /* @__PURE__ */ Lt(
+                  Ee,
+                  {
+                    index: t,
+                    item: e,
+                    position: dt.get(t),
+                    useTransform: I,
+                    itemStyle: F,
+                    itemClassName: z,
+                    renderItem: b,
+                    onClick: ne,
+                    itemRef: me(t)
+                  },
+                  R(e, t)
+                );
+              })
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+export {
+  Ve as W,
+  Ie as a,
+  Se as b,
+  Me as c
+};