vft 0.0.249 → 0.0.252

package/es/components/virtual-list/builders/build-list.d.ts

@@ -1,6 +1,6 @@
 import type { CSSProperties } from 'vue';
-import type { VirtualizedListProps } from '../props';
 import type { Alignment, ListConstructorProps } from '../types';
+import type { VirtualizedListProps } from '../props';
 declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEstimatedTotalSize, getStartIndexForOffset, getStopIndexForStartIndex, initCache, clearCache, validateProps, }: ListConstructorProps<VirtualizedListProps>) => import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly className: import("vft/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
     readonly containerElement: import("vft/es/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
@@ -19,7 +19,7 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    readonly useIsScrolling: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly useIsScrolling: BooleanConstructor;
     readonly width: {
         readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
         readonly required: false;
@@ -27,7 +27,7 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
         __epPropKey: true;
     };
     readonly perfMode: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
-    readonly scrollbarAlwaysOn: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
     readonly cache: import("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
     readonly estimatedItemSize: {
         readonly type: import("vue").PropType<number>;
@@ -51,7 +51,7 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
     };
 }>, {
     ns: {
-        namespace: import("vue").Ref<string, string>;
+        namespace: import("vue").ComputedRef<string>;
         b: (blockSuffix?: string) => string;
         e: (element?: string) => string;
         m: (modifier?: string) => string;
@@ -63,9 +63,9 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
             (name: string, state: boolean | undefined): string;
             (name: string): string;
         };
-        cssVar: (object: Record<string, string | undefined>) => Record<string, string>;
+        cssVar: (object: Record<string, string>) => Record<string, string>;
         cssVarName: (name: string) => string;
-        cssVarBlock: (object: Record<string, string | undefined>) => Record<string, string>;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
         cssVarBlockName: (name: string) => string;
     };
     clientSize: import("vue").ComputedRef<string | number | undefined>;
@@ -91,21 +91,21 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
         scrollOffset: number;
         updateRequested: boolean;
         isScrollbarDragging: boolean;
-        scrollbarAlwaysOn: import("vft/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        scrollbarAlwaysOn: boolean;
     }, {
         isScrolling: boolean;
         scrollDir: string;
         scrollOffset: number;
         updateRequested: boolean;
         isScrollbarDragging: boolean;
-        scrollbarAlwaysOn: import("vft/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        scrollbarAlwaysOn: boolean;
     } | {
         isScrolling: boolean;
         scrollDir: string;
         scrollOffset: number;
         updateRequested: boolean;
         isScrollbarDragging: boolean;
-        scrollbarAlwaysOn: import("vft/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        scrollbarAlwaysOn: boolean;
     }>;
     getItemStyle: (idx: number) => CSSProperties;
     onScroll: (e: Event) => void;
@@ -132,7 +132,7 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    readonly useIsScrolling: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly useIsScrolling: BooleanConstructor;
     readonly width: {
         readonly type: import("vue").PropType<import("vft/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
         readonly required: false;
@@ -140,7 +140,7 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
         __epPropKey: true;
     };
     readonly perfMode: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
-    readonly scrollbarAlwaysOn: import("vft/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
     readonly cache: import("vft/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
     readonly estimatedItemSize: {
         readonly type: import("vue").PropType<number>;
@@ -171,11 +171,11 @@ declare const createList: ({ name, getOffset, getItemSize, getItemOffset, getEst
     readonly cache: number;
     readonly className: string;
     readonly layout: import("vft/es/utils").EpPropMergeType<StringConstructor, "vertical" | "horizontal", never>;
+    readonly scrollbarAlwaysOn: boolean;
     readonly containerElement: import("vft/es/utils").EpPropMergeType<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown>;
     readonly innerElement: import("vft/es/utils").EpPropMergeType<readonly [StringConstructor, ObjectConstructor], unknown, unknown>;
-    readonly useIsScrolling: import("vft/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     readonly perfMode: import("vft/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    readonly scrollbarAlwaysOn: import("vft/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly useIsScrolling: boolean;
     readonly initScrollOffset: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default createList;

package/es/components/virtual-list/builders/build-list.js

@@ -1,19 +1,19 @@
-import { isString as j, isNumber as k, hasOwn as ft } from "@vft/utils";
-import { isClient as ut } from "@vueuse/core";
+import { defineComponent as ft, resolveDynamicComponent as j, h as M, Fragment as ut, getCurrentInstance as dt, ref as x, computed as d, unref as l, onMounted as mt, onUpdated as ht, onActivated as St, nextTick as $ } from "vue";
+import { useEventListener as wt } from "@vueuse/core";
+import { isString as p, isNumber as F, isClient as Ot, hasOwn as gt } from "@vft/utils";
 import "../../../utils/ns-cover.js";
 import "lodash-es";
-import { defineComponent as dt, resolveDynamicComponent as J, h as A, getCurrentInstance as mt, ref as x, computed as u, unref as s, onMounted as ht, onUpdated as St, nextTick as $ } from "vue";
-import { useNamespace as gt } from "../../../hooks/use-namespace/index.js";
+import { useNamespace as vt } from "../../../hooks/use-namespace/index.js";
 import "../../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../../hooks/use-z-index/index.js";
-import wt from "../components/scrollbar.js";
-import { ITEM_RENDER_EVT as Q, SCROLL_EVT as X, HORIZONTAL as Ot, RTL as U, RTL_OFFSET_POS_ASC as vt, RTL_OFFSET_NAG as Y, AUTO_ALIGNMENT as yt, BACKWARD as Tt, FORWARD as Rt, RTL_OFFSET_POS_DESC as Et } from "../defaults.js";
-import { useCache as bt } from "../hooks/use-cache.js";
-import Lt from "../hooks/use-wheel.js";
-import { virtualizedListProps as Mt } from "../props.js";
-import { isHorizontal as xt, getRTLOffsetType as p, getScrollDir as G } from "../utils.js";
-const Pt = ({
+import { useCache as yt } from "../hooks/use-cache.js";
+import Tt from "../hooks/use-wheel.js";
+import Rt from "../components/scrollbar.js";
+import { isHorizontal as Et, getRTLOffsetType as J, getScrollDir as P } from "../utils.js";
+import { virtualizedListProps as bt } from "../props.js";
+import { ITEM_RENDER_EVT as Q, SCROLL_EVT as X, HORIZONTAL as Lt, RTL as U, RTL_OFFSET_POS_ASC as Mt, RTL_OFFSET_NAG as Y, AUTO_ALIGNMENT as xt, BACKWARD as zt, FORWARD as _t, RTL_OFFSET_POS_DESC as It } from "../defaults.js";
+const Kt = ({
   name: tt,
   getOffset: et,
   getItemSize: lt,
@@ -21,320 +21,328 @@ const Pt = ({
   getEstimatedTotalSize: st,
   getStartIndexForOffset: nt,
   getStopIndexForStartIndex: rt,
-  initCache: it,
-  clearCache: W,
-  validateProps: ct
-}) => dt({
-  name: tt ?? "VftVirtualList",
-  props: Mt,
+  initCache: ct,
+  clearCache: N,
+  validateProps: it
+}) => ft({
+  name: tt ?? "ElVirtualList",
+  props: bt,
   emits: [Q, X],
-  setup(e, { emit: z, expose: F }) {
-    ct(e);
-    const y = mt(), N = gt("vl"), d = x(it(e, y)), T = bt(), g = x(), _ = x(), I = x(), r = x({
+  setup(e, { emit: z, expose: W }) {
+    it(e);
+    const T = dt(), H = vt("vl"), m = x(ct(e, T)), R = yt(), f = x(), _ = x(), I = x(), r = x({
       isScrolling: !1,
       scrollDir: "forward",
-      scrollOffset: k(e.initScrollOffset) ? e.initScrollOffset : 0,
+      scrollOffset: F(e.initScrollOffset) ? e.initScrollOffset : 0,
       updateRequested: !1,
       isScrollbarDragging: !1,
       scrollbarAlwaysOn: e.scrollbarAlwaysOn
-    }), R = u(() => {
-      const { total: t, cache: l } = e, { isScrolling: n, scrollDir: a, scrollOffset: o } = s(r);
+    }), E = d(() => {
+      const { total: t, cache: o } = e, { isScrolling: n, scrollDir: a, scrollOffset: s } = l(r);
       if (t === 0)
         return [0, 0, 0, 0];
-      const i = nt(
+      const c = nt(
         e,
-        o,
-        s(d)
-      ), c = rt(
+        s,
+        l(m)
+      ), i = rt(
         e,
-        i,
-        o,
-        s(d)
-      ), O = !n || a === Tt ? Math.max(1, l) : 1, v = !n || a === Rt ? Math.max(1, l) : 1;
+        c,
+        s,
+        l(m)
+      ), v = !n || a === zt ? Math.max(1, o) : 1, y = !n || a === _t ? Math.max(1, o) : 1;
       return [
-        Math.max(0, i - O),
-        Math.max(0, Math.min(t - 1, c + v)),
-        i,
-        c
+        Math.max(0, c - v),
+        Math.max(0, Math.min(t - 1, i + y)),
+        c,
+        i
       ];
-    }), m = u(
-      () => st(e, s(d))
-    ), h = u(() => xt(e.layout)), H = u(() => [
+    }), h = d(
+      () => st(e, l(m))
+    ), S = d(() => Et(e.layout)), O = d(() => [
       {
         position: "relative",
-        [`overflow-${h.value ? "x" : "y"}`]: "scroll",
+        [`overflow-${S.value ? "x" : "y"}`]: "scroll",
         WebkitOverflowScrolling: "touch",
         willChange: "transform"
       },
       {
         direction: e.direction,
-        height: k(e.height) ? `${e.height}px` : e.height,
-        width: k(e.width) ? `${e.width}px` : e.width
+        height: F(e.height) ? `${e.height}px` : e.height,
+        width: F(e.width) ? `${e.width}px` : e.width
       },
       e.style
-    ]), E = u(() => {
-      const t = s(m), l = s(h);
+    ]), q = d(() => {
+      const t = l(h), o = l(S);
       return {
-        height: l ? "100%" : `${t}px`,
-        pointerEvents: s(r).isScrolling ? "none" : void 0,
-        width: l ? `${t}px` : "100%"
+        height: o ? "100%" : `${t}px`,
+        pointerEvents: l(r).isScrolling ? "none" : void 0,
+        width: o ? `${t}px` : "100%"
       };
-    }), w = u(
-      () => h.value ? e.width : e.height
-    ), { onWheel: q } = Lt(
+    }), g = d(
+      () => S.value ? e.width : e.height
+    ), { onWheel: b } = Tt(
       {
-        atStartEdge: u(() => r.value.scrollOffset <= 0),
-        atEndEdge: u(
-          () => r.value.scrollOffset >= m.value
+        atStartEdge: d(() => r.value.scrollOffset <= 0),
+        atEndEdge: d(
+          () => r.value.scrollOffset >= h.value
         ),
-        layout: u(() => e.layout)
+        layout: d(() => e.layout)
       },
       (t) => {
-        I.value.onMouseUp?.(), f(
+        I.value.onMouseUp?.(), w(
           Math.min(
             r.value.scrollOffset + t,
-            m.value - w.value
+            h.value - g.value
           )
         );
       }
-    ), b = () => {
+    );
+    wt(f, "wheel", b, {
+      passive: !1
+    });
+    const A = () => {
       const { total: t } = e;
       if (t > 0) {
-        const [o, i, c, O] = s(R);
-        z(Q, o, i, c, O);
+        const [s, c, i, v] = l(E);
+        z(Q, s, c, i, v);
       }
-      const { scrollDir: l, scrollOffset: n, updateRequested: a } = s(r);
-      z(X, l, n, a);
+      const { scrollDir: o, scrollOffset: n, updateRequested: a } = l(r);
+      z(X, o, n, a);
     }, V = (t) => {
-      const { clientHeight: l, scrollHeight: n, scrollTop: a } = t.currentTarget, o = s(r);
-      if (o.scrollOffset === a)
+      const { clientHeight: o, scrollHeight: n, scrollTop: a } = t.currentTarget, s = l(r);
+      if (s.scrollOffset === a)
         return;
-      const i = Math.max(
+      const c = Math.max(
         0,
-        Math.min(a, n - l)
+        Math.min(a, n - o)
       );
       r.value = {
-        ...o,
+        ...s,
         isScrolling: !0,
-        scrollDir: G(o.scrollOffset, i),
-        scrollOffset: i,
+        scrollDir: P(s.scrollOffset, c),
+        scrollOffset: c,
         updateRequested: !1
-      }, $(M);
-    }, B = (t) => {
-      const { clientWidth: l, scrollLeft: n, scrollWidth: a } = t.currentTarget, o = s(r);
-      if (o.scrollOffset === n)
+      }, $(u);
+    }, C = (t) => {
+      const { clientWidth: o, scrollLeft: n, scrollWidth: a } = t.currentTarget, s = l(r);
+      if (s.scrollOffset === n)
         return;
-      const { direction: i } = e;
-      let c = n;
-      if (i === U)
-        switch (p()) {
+      const { direction: c } = e;
+      let i = n;
+      if (c === U)
+        switch (J()) {
           case Y: {
-            c = -n;
+            i = -n;
             break;
           }
-          case Et: {
-            c = a - l - n;
+          case It: {
+            i = a - o - n;
             break;
           }
         }
-      c = Math.max(
+      i = Math.max(
         0,
-        Math.min(c, a - l)
+        Math.min(i, a - o)
       ), r.value = {
-        ...o,
+        ...s,
         isScrolling: !0,
-        scrollDir: G(o.scrollOffset, c),
-        scrollOffset: c,
+        scrollDir: P(s.scrollOffset, i),
+        scrollOffset: i,
         updateRequested: !1
-      }, $(M);
-    }, C = (t) => {
-      s(h) ? B(t) : V(t), b();
-    }, D = (t, l) => {
-      const n = (m.value - w.value) / l * t;
-      f(
+      }, $(u);
+    }, D = (t) => {
+      l(S) ? C(t) : V(t), A();
+    }, L = (t, o) => {
+      const n = (h.value - g.value) / o * t;
+      w(
         Math.min(
-          m.value - w.value,
+          h.value - g.value,
           n
         )
       );
-    }, f = (t) => {
-      t = Math.max(t, 0), t !== s(r).scrollOffset && (r.value = {
-        ...s(r),
+    }, w = (t) => {
+      t = Math.max(t, 0), t !== l(r).scrollOffset && (r.value = {
+        ...l(r),
         scrollOffset: t,
-        scrollDir: G(s(r).scrollOffset, t),
+        scrollDir: P(l(r).scrollOffset, t),
         updateRequested: !0
-      }, $(M));
-    }, L = (t, l = yt) => {
-      const { scrollOffset: n } = s(r);
-      t = Math.max(0, Math.min(t, e.total - 1)), f(
+      }, $(u));
+    }, k = (t, o = xt) => {
+      const { scrollOffset: n } = l(r);
+      t = Math.max(0, Math.min(t, e.total - 1)), w(
         et(
           e,
           t,
-          l,
+          o,
           n,
-          s(d)
+          l(m)
         )
       );
-    }, P = (t) => {
-      const { direction: l, itemSize: n, layout: a } = e, o = T.value(
-        W && n,
-        W && a,
-        W && l
+    }, B = (t) => {
+      const { direction: o, itemSize: n, layout: a } = e, s = R.value(
+        N && n,
+        N && a,
+        N && o
       );
-      let i;
-      if (ft(o, String(t)))
-        i = o[t];
+      let c;
+      if (gt(s, String(t)))
+        c = s[t];
       else {
-        const c = ot(e, t, s(d)), O = lt(e, t, s(d)), v = s(h), K = l === U, Z = v ? c : 0;
-        o[t] = i = {
+        const i = ot(e, t, l(m)), v = lt(e, t, l(m)), y = l(S), K = o === U, Z = y ? i : 0;
+        s[t] = c = {
           position: "absolute",
           left: K ? void 0 : `${Z}px`,
           right: K ? `${Z}px` : void 0,
-          top: v ? 0 : `${c}px`,
-          height: v ? "100%" : `${O}px`,
-          width: v ? `${O}px` : "100%"
+          top: y ? 0 : `${i}px`,
+          height: y ? "100%" : `${v}px`,
+          width: y ? `${v}px` : "100%"
         };
       }
-      return i;
-    }, M = () => {
+      return c;
+    }, u = () => {
       r.value.isScrolling = !1, $(() => {
-        T.value(-1, null, null);
+        R.value(-1, null, null);
       });
-    }, S = () => {
-      const t = g.value;
+    }, G = () => {
+      const t = f.value;
       t && (t.scrollTop = 0);
     };
-    ht(() => {
-      if (!ut) return;
-      const { initScrollOffset: t } = e, l = s(g);
-      k(t) && l && (s(h) ? l.scrollLeft = t : l.scrollTop = t), b();
-    }), St(() => {
-      const { direction: t, layout: l } = e, { scrollOffset: n, updateRequested: a } = s(r), o = s(g);
-      if (a && o)
-        if (l === Ot)
+    mt(() => {
+      if (!Ot) return;
+      const { initScrollOffset: t } = e, o = l(f);
+      F(t) && o && (l(S) ? o.scrollLeft = t : o.scrollTop = t), A();
+    }), ht(() => {
+      const { direction: t, layout: o } = e, { scrollOffset: n, updateRequested: a } = l(r), s = l(f);
+      if (a && s)
+        if (o === Lt)
           if (t === U)
-            switch (p()) {
+            switch (J()) {
               case Y: {
-                o.scrollLeft = -n;
+                s.scrollLeft = -n;
                 break;
               }
-              case vt: {
-                o.scrollLeft = n;
+              case Mt: {
+                s.scrollLeft = n;
                 break;
               }
               default: {
-                const { clientWidth: i, scrollWidth: c } = o;
-                o.scrollLeft = c - i - n;
+                const { clientWidth: c, scrollWidth: i } = s;
+                s.scrollLeft = i - c - n;
                 break;
               }
             }
           else
-            o.scrollLeft = n;
+            s.scrollLeft = n;
         else
-          o.scrollTop = n;
+          s.scrollTop = n;
+    }), St(() => {
+      l(f).scrollTop = l(r).scrollOffset;
     });
     const at = {
-      ns: N,
-      clientSize: w,
-      estimatedTotalSize: m,
-      windowStyle: H,
-      windowRef: g,
+      ns: H,
+      clientSize: g,
+      estimatedTotalSize: h,
+      windowStyle: O,
+      windowRef: f,
       innerRef: _,
-      innerStyle: E,
-      itemsToRender: R,
+      innerStyle: q,
+      itemsToRender: E,
       scrollbarRef: I,
       states: r,
-      getItemStyle: P,
-      onScroll: C,
-      onScrollbarScroll: D,
-      onWheel: q,
-      scrollTo: f,
-      scrollToItem: L,
-      resetScrollTop: S
+      getItemStyle: B,
+      onScroll: D,
+      onScrollbarScroll: L,
+      onWheel: b,
+      scrollTo: w,
+      scrollToItem: k,
+      resetScrollTop: G
     };
-    return F({
-      windowRef: g,
+    return W({
+      windowRef: f,
       innerRef: _,
-      getItemStyleCache: T,
-      scrollTo: f,
-      scrollToItem: L,
-      resetScrollTop: S,
+      getItemStyleCache: R,
+      scrollTo: w,
+      scrollToItem: k,
+      resetScrollTop: G,
       states: r
     }), at;
   },
   render(e) {
     const {
       $slots: z,
-      className: F,
-      clientSize: y,
-      containerElement: N,
-      data: d,
-      getItemStyle: T,
-      innerElement: g,
+      className: W,
+      clientSize: T,
+      containerElement: H,
+      data: m,
+      getItemStyle: R,
+      innerElement: f,
       itemsToRender: _,
       innerStyle: I,
       layout: r,
-      total: R,
-      onScroll: m,
-      onScrollbarScroll: h,
-      onWheel: H,
-      states: E,
-      useIsScrolling: w,
-      windowStyle: q,
+      total: E,
+      onScroll: h,
+      onScrollbarScroll: S,
+      states: O,
+      useIsScrolling: q,
+      windowStyle: g,
       ns: b
-    } = e, [V, B] = _, C = J(N), D = J(g), f = [];
-    if (R > 0)
-      for (let S = V; S <= B; S++)
-        f.push(
-          z.default?.({
-            data: d,
-            key: S,
-            index: S,
-            isScrolling: w ? E.isScrolling : void 0,
-            style: T(S)
-          })
+    } = e, [A, V] = _, C = j(H), D = j(f), L = [];
+    if (E > 0)
+      for (let u = A; u <= V; u++)
+        L.push(
+          M(
+            ut,
+            { key: u },
+            z.default?.({
+              data: m,
+              index: u,
+              isScrolling: q ? O.isScrolling : void 0,
+              style: R(u)
+            })
+          )
         );
-    const L = [
-      A(
+    const w = [
+      M(
         D,
         {
           style: I,
           ref: "innerRef"
         },
-        j(D) ? f : {
-          default: () => f
+        p(D) ? L : {
+          default: () => L
         }
       )
-    ], P = A(wt, {
+    ], k = M(Rt, {
       ref: "scrollbarRef",
-      clientSize: y,
+      clientSize: T,
       layout: r,
-      onScroll: h,
-      ratio: y * 100 / this.estimatedTotalSize,
-      scrollFrom: E.scrollOffset / (this.estimatedTotalSize - y),
-      total: R
-    }), M = A(
+      onScroll: S,
+      ratio: T * 100 / this.estimatedTotalSize,
+      scrollFrom: O.scrollOffset / (this.estimatedTotalSize - T),
+      total: E,
+      alwaysOn: O.scrollbarAlwaysOn
+    }), B = M(
       C,
       {
-        class: [b.e("window"), F],
-        style: q,
-        onScroll: m,
-        onWheel: H,
+        class: [b.e("window"), W],
+        style: g,
+        onScroll: h,
         ref: "windowRef",
         key: 0
       },
-      j(C) ? [L] : { default: () => [L] }
+      p(C) ? [w] : { default: () => [w] }
     );
-    return A(
+    return M(
       "div",
       {
         key: 0,
-        class: [b.e("wrapper"), E.scrollbarAlwaysOn ? "always-on" : ""]
+        class: [b.e("wrapper"), O.scrollbarAlwaysOn ? "always-on" : ""]
       },
-      [M, P]
+      [B, k]
     );
   }
 });
 export {
-  Pt as default
+  Kt as default
 };