ep-craft 0.1.26 → 0.1.27

package/dist/components/time-picker/src/time-picker.d.ts

@@ -3,7 +3,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
      * @description whether to pick a time range
      */
     isRange: BooleanConstructor;
-    floatLabel: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
     showNow: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     showConfirm: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     showFooter: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -206,7 +205,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
      * @description whether to pick a time range
      */
     isRange: BooleanConstructor;
-    floatLabel: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
     showNow: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     showConfirm: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     showFooter: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -414,7 +412,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     placement: import("../../../utils").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
     modelValue: import("../../../utils").EpPropMergeType<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => import("..").ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => import("..").ModelValueType | null)) | null)[], unknown, unknown>;
     valueOnClear: import("../../../utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
-    floatLabel: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     readonly: boolean;
     clearable: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     clearIcon: import("../../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;

package/dist/components/virtual-list/index.d.ts

@@ -0,0 +1,8 @@
+import FixedSizeList from './src/components/fixed-size-list';
+import DynamicSizeList from './src/components/dynamic-size-list';
+export { DynamicSizeList, FixedSizeList };
+export { virtualizedListProps, virtualizedProps, virtualizedScrollbarProps, } from './src/props';
+export type { Alignment, Direction, ExposesStates, GetEstimatedTotalSize, GetGridOffset, GetOffset, GetPosition, GetStartIndexForOffset, GetStopIndexForStartIndex, GridCache, GridConstructorProps, GridDefaultSlotParams, GridExposes, GridItemKeyGetter, GridItemRenderedEvtParams, GridScrollOptions, GridStates, InitCacheFunc, InitGridCacheFunc, InitListCacheFunc, Instance, ItemProps, ItemSize, LayoutDirection, ListCache, ListConstructorProps, ListExposes, ListItem, ListItemSizer, PropValidator, RTLOffsetType, ScrollDir, ScrollDirection, ScrollbarExpose, SharedExposes, } from './src/types';
+export type { VirtualizedListProps, VirtualizedListPropsPublic, VirtualizedProps, VirtualizedPropsPublic, VirtualizedScrollbarProps, VirtualizedScrollbarPropsPublic, } from './src/props';
+export type { DynamicSizeListInstance } from './src/components/dynamic-size-list';
+export type { FixedSizeListInstance } from './src/components/fixed-size-list';

package/dist/components/virtual-list/src/builders/build-list.d.ts

@@ -0,0 +1,187 @@
+import type { CSSProperties } from 'vue';
+import type { Alignment, ListConstructorProps, ScrollDirection } 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("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly containerElement: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+    readonly height: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerElement: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+    readonly innerProps: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerWidth: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly perfMode: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly cache: import("@element-plus/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly estimatedItemSize: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly layout: import("@element-plus/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+    readonly initScrollOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly total: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly itemSize: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => number | import("../types").ItemSize) | (() => number | import("../types").ItemSize) | (((new (...args: any[]) => number | import("../types").ItemSize) | (() => number | import("../types").ItemSize)) | null)[], never, never>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    clientSize: import("vue").ComputedRef<string | number | undefined>;
+    estimatedTotalSize: import("vue").ComputedRef<number>;
+    windowStyle: import("vue").ComputedRef<(string | false | CSSProperties | import("vue").StyleValue[] | {
+        [x: string]: string;
+        position: string;
+        WebkitOverflowScrolling: string;
+        willChange: string;
+    } | null | undefined)[]>;
+    windowRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    innerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    innerStyle: import("vue").ComputedRef<{
+        height: string;
+        pointerEvents: string | undefined;
+        width: string;
+        margin: number;
+        boxSizing: string;
+    }>;
+    itemsToRender: import("vue").ComputedRef<number[]>;
+    scrollbarRef: import("vue").Ref<any, any>;
+    states: import("vue").Ref<{
+        isScrolling: boolean;
+        scrollDir: ScrollDirection;
+        scrollOffset: number;
+        updateRequested: boolean;
+        isScrollbarDragging: boolean;
+    }, {
+        isScrolling: boolean;
+        scrollDir: ScrollDirection;
+        scrollOffset: number;
+        updateRequested: boolean;
+        isScrollbarDragging: boolean;
+    } | {
+        isScrolling: boolean;
+        scrollDir: ScrollDirection;
+        scrollOffset: number;
+        updateRequested: boolean;
+        isScrollbarDragging: boolean;
+    }>;
+    getItemStyle: (idx: number) => CSSProperties;
+    onScroll: (e: Event) => void;
+    onScrollbarScroll: (distanceToGo: number, totalSteps: number) => void;
+    onWheel: (e: WheelEvent) => void;
+    scrollTo: (offset: number) => void;
+    scrollToItem: (idx: number, alignment?: Alignment) => void;
+    resetScrollTop: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "itemRendered" | "end-reached")[], "scroll" | "itemRendered" | "end-reached", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly className: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly containerElement: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+    readonly height: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerElement: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+    readonly innerProps: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly innerWidth: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly perfMode: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly cache: import("@element-plus/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly estimatedItemSize: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly layout: import("@element-plus/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+    readonly initScrollOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+    readonly total: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly itemSize: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => number | import("../types").ItemSize) | (() => number | import("../types").ItemSize) | (((new (...args: any[]) => number | import("../types").ItemSize) | (() => number | import("../types").ItemSize)) | null)[], never, never>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{
+    onScroll?: ((...args: any[]) => any) | undefined;
+    "onEnd-reached"?: ((...args: any[]) => any) | undefined;
+    onItemRendered?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly data: any[];
+    readonly layout: import("@element-plus/utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", never>;
+    readonly style: import("vue").StyleValue;
+    readonly direction: import("@element-plus/utils").EpPropMergeType<StringConstructor, "ltr" | "rtl", never>;
+    readonly className: string;
+    readonly containerElement: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown>;
+    readonly innerElement: import("@element-plus/utils").EpPropMergeType<readonly [StringConstructor, ObjectConstructor], unknown, unknown>;
+    readonly innerProps: Record<string, unknown>;
+    readonly perfMode: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly useIsScrolling: boolean;
+    readonly scrollbarAlwaysOn: boolean;
+    readonly cache: number;
+    readonly initScrollOffset: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default createList;

package/dist/components/virtual-list/src/builders/build-list.js

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