code:
import type { SetupContext, UnwrapRef } from 'vue';
import type { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
import type { ComponentSize } from 'element-plus/es/constants';
import type { Arrayable } from 'element-plus/es/utils';
import type { MaybeRef } from '@vueuse/core';
import type { FormItemProp, FormItemProps, FormItemValidateState } from './form-item';
import type { FormEmits, FormProps } from './form';
import type { useFormLabelWidth } from './utils';
export declare type FormLabelWidthContext = ReturnType<typeof useFormLabelWidth>;
export interface FormItemRule extends RuleItem {
    trigger?: Arrayable<string>;
}
declare type Primitive = null | undefined | string | number | boolean | symbol | bigint;
declare type BrowserNativeObject = Date | FileList | File | Blob | RegExp;
/**
 * Check whether it is tuple
 *
 * 检查是否为元组
 *
 * @example
 * IsTuple<[1, 2, 3]> => true
 * IsTuple<Array[number]> => false
 */
declare type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
/**
 * Array method key
 *
 * 数组方法键
 */
declare type ArrayMethodKey = keyof any[];
/**
 * Tuple index key
 *
 * 元组下标键
 *
 * @example
 * TupleKey<[1, 2, 3]> => '0' | '1' | '2'
 */
declare type TupleKey<T extends ReadonlyArray<any>> = Exclude<keyof T, ArrayMethodKey>;
/**
 * Array index key
 *
 * 数组下标键
 */
declare type ArrayKey = number;
/**
 * Helper type for recursively constructing paths through a type
 *
 * 用于通过一个类型递归构建路径的辅助类型
 */
declare type PathImpl<K extends string | number, V> = V extends Primitive | BrowserNativeObject ? `${K}` : `${K}` | `${K}.${Path<V>}`;
/**
 * Type which collects all paths through a type
 *
 * 通过一个类型收集所有路径的类型
 *
 * @see {@link FieldPath}
 */
declare type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
    [K in TupleKey<T>]-?: PathImpl<Exclude<K, symbol>, T[K]>;
}[TupleKey<T>] : PathImpl<ArrayKey, V> : {
    [K in keyof T]-?: PathImpl<Exclude<K, symbol>, T[K]>;
}[keyof T];
/**
 * Type which collects all paths through a type
 *
 * 通过一个类型收集所有路径的类型
 *
 * @example
 * FieldPath<{ 1: number; a: number; b: string; c: { d: number; e: string }; f: [{ value: string }]; g: { value: string }[]; h: Date; i: FileList; j: File; k: Blob; l: RegExp }> => '1' | 'a' | 'b' | 'c' | 'f' | 'g' | 'c.d' | 'c.e' | 'f.0' | 'f.0.value' | 'g.number' | 'g.number.value' | 'h' | 'i' | 'j' | 'k' | 'l'
 */
declare type FieldPath<T> = T extends object ? Path<T> : never;
export declare type FormRules<T extends MaybeRef<Record<string, any> | string> = string> = Partial<Record<UnwrapRef<T> extends string ? UnwrapRef<T> : FieldPath<UnwrapRef<T>>, Arrayable<FormItemRule>>>;
export declare type FormValidationResult = Promise<boolean>;
export declare type FormValidateCallback = (isValid: boolean, invalidFields?: ValidateFieldsError) => Promise<void> | void;
export interface FormValidateFailure {
    errors: ValidateError[] | null;
    fields: ValidateFieldsError;
}
export declare type FormContext = FormProps & UnwrapRef<FormLabelWidthContext> & {
    emit: SetupContext<FormEmits>['emit'];
    getField: (prop: string) => FormItemContext | undefined;
    addField: (field: FormItemContext) => void;
    removeField: (field: FormItemContext) => void;
    resetFields: (props?: Arrayable<FormItemProp>) => void;
    clearValidate: (props?: Arrayable<FormItemProp>) => void;
    validateField: (props?: Arrayable<FormItemProp>, callback?: FormValidateCallback) => FormValidationResult;
};
export interface FormItemContext extends FormItemProps {
    $el: HTMLDivElement | undefined;
    size: ComponentSize;
    validateState: FormItemValidateState;
    isGroup: boolean;
    labelId: string;
    inputIds: string[];
    hasLabel: boolean;
    fieldValue: any;
    addInputId: (id: string) => void;
    removeInputId: (id: string) => void;
    validate: (trigger: string, callback?: FormValidateCallback) => FormValidationResult;
    resetField(): void;
    clearValidate(): void;
}
export {};


code:
'use strict';

//# sourceMappingURL=types.js.map

license: mit


code:
import type { Arrayable } from 'element-plus/es/utils';
import type { FormItemContext } from './types';
import type { FormItemProp } from './form-item';
export declare function useFormLabelWidth(): {
    autoLabelWidth: import("vue").ComputedRef<string>;
    registerLabelWidth: (val: number, oldVal: number) => void;
    deregisterLabelWidth: (val: number) => void;
};
export declare const filterFields: (fields: FormItemContext[], props: Arrayable<FormItemProp>) => FormItemContext[];


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
require('../../../utils/index.js');
var error = require('../../../utils/error.js');
var lodashUnified = require('lodash-unified');

const SCOPE = "ElForm";
function useFormLabelWidth() {
  const potentialLabelWidthArr = vue.ref([]);
  const autoLabelWidth = vue.computed(() => {
    if (!potentialLabelWidthArr.value.length)
      return "0";
    const max = Math.max(...potentialLabelWidthArr.value);
    return max ? `${max}px` : "";
  });
  function getLabelWidthIndex(width) {
    const index = potentialLabelWidthArr.value.indexOf(width);
    if (index === -1 && autoLabelWidth.value === "0") {
      error.debugWarn(SCOPE, `unexpected width ${width}`);
    }
    return index;
  }
  function registerLabelWidth(val, oldVal) {
    if (val && oldVal) {
      const index = getLabelWidthIndex(oldVal);
      potentialLabelWidthArr.value.splice(index, 1, val);
    } else if (val) {
      potentialLabelWidthArr.value.push(val);
    }
  }
  function deregisterLabelWidth(val) {
    const index = getLabelWidthIndex(val);
    if (index > -1) {
      potentialLabelWidthArr.value.splice(index, 1);
    }
  }
  return {
    autoLabelWidth,
    registerLabelWidth,
    deregisterLabelWidth
  };
}
const filterFields = (fields, props) => {
  const normalized = lodashUnified.castArray(props);
  return normalized.length > 0 ? fields.filter((field) => field.prop && normalized.includes(field.prop)) : fields;
};

exports.filterFields = filterFields;
exports.useFormLabelWidth = useFormLabelWidth;
//# sourceMappingURL=utils.js.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-form.css';


code:
'use strict';

require('../../base/style/css.js');
require('element-plus/theme-chalk/el-form.css');

//# sourceMappingURL=css.js.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/form.scss';


code:
'use strict';

require('../../base/style/index.js');
require('element-plus/theme-chalk/src/form.scss');

//# sourceMappingURL=index.js.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-header.css';


code:
'use strict';

require('../../base/style/css.js');
require('element-plus/theme-chalk/el-header.css');

//# sourceMappingURL=css.js.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/header.scss';


code:
'use strict';

require('../../base/style/index.js');
require('element-plus/theme-chalk/src/header.scss');

//# sourceMappingURL=index.js.map


code:
import Icon from './src/icon.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElIcon: SFCWithInstall<typeof Icon>;
export default ElIcon;
export * from './src/icon';


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require('../../utils/index.js');
var icon$1 = require('./src/icon2.js');
var icon = require('./src/icon.js');
var install = require('../../utils/vue/install.js');

const ElIcon = install.withInstall(icon$1["default"]);

exports.iconProps = icon.iconProps;
exports.ElIcon = ElIcon;
exports["default"] = ElIcon;
//# sourceMappingURL=index.js.map


sourcesContent:
import { withInstall } from '@element-plus/utils'

import Icon from './src/icon.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElIcon: SFCWithInstall<typeof Icon> = withInstall(Icon)
export default ElIcon

export * from './src/icon'

names: withInstall Icon


code:
import type { ExtractPropTypes } from 'vue';
import type Icon from './icon.vue';
export declare const iconProps: {
    readonly size: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly color: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
};
export declare type IconProps = ExtractPropTypes<typeof iconProps>;
export declare type IconInstance = InstanceType<typeof Icon>;


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require('../../../utils/index.js');
var runtime = require('../../../utils/vue/props/runtime.js');

const iconProps = runtime.buildProps({
  size: {
    type: runtime.definePropType([Number, String])
  },
  color: {
    type: String
  }
});

exports.iconProps = iconProps;
//# sourceMappingURL=icon.js.map


sourcesContent:
import { buildProps, definePropType } from '@element-plus/utils'
import type { ExtractPropTypes } from 'vue'
import type Icon from './icon.vue'

export const iconProps = buildProps({
  /**
   * @description SVG icon size, size x size
   */
  size: {
    type: definePropType<number | string>([Number, String]),
  },
  /**
   * @description SVG tag's fill attribute
   */
  color: {
    type: String,
  },
} as const)
export type IconProps = ExtractPropTypes<typeof iconProps>
export type IconInstance = InstanceType<typeof Icon>

names: buildProps definePropType


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    readonly size: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly color: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly size: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly color: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
}>>, {}>, {
    default?(_: {}): any;
}>;
export default _default;
declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
require('../../../utils/index.js');
require('../../../hooks/index.js');
var icon = require('./icon.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
var index = require('../../../hooks/use-namespace/index.js');
var types = require('../../../utils/types.js');
var style = require('../../../utils/dom/style.js');

const __default__ = vue.defineComponent({
  name: "ElIcon",
  inheritAttrs: false
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...__default__,
  props: icon.iconProps,
  setup(__props) {
    const props = __props;
    const ns = index.useNamespace("icon");
    const style$1 = vue.computed(() => {
      const { size, color } = props;
      if (!size && !color)
        return {};
      return {
        fontSize: types.isUndefined(size) ? void 0 : style.addUnit(size),
        "--color": color
      };
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createElementBlock("i", vue.mergeProps({
        class: vue.unref(ns).b(),
        style: vue.unref(style$1)
      }, _ctx.$attrs), [
        vue.renderSlot(_ctx.$slots, "default")
      ], 16);
    };
  }
});
var Icon = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "icon.vue"]]);

exports["default"] = Icon;
//# sourceMappingURL=icon2.js.map


code:
'use strict';

require('../../base/style/css.js');

//# sourceMappingURL=css.js.map


code:
'use strict';

require('../../base/style/index.js');

//# sourceMappingURL=index.js.map


code:
import ImageViewer from './src/image-viewer.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElImageViewer: SFCWithInstall<typeof ImageViewer>;
export default ElImageViewer;
export * from './src/image-viewer';


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require('../../utils/index.js');
var imageViewer$1 = require('./src/image-viewer2.js');
var imageViewer = require('./src/image-viewer.js');
var install = require('../../utils/vue/install.js');

const ElImageViewer = install.withInstall(imageViewer$1["default"]);

exports.imageViewerEmits = imageViewer.imageViewerEmits;
exports.imageViewerProps = imageViewer.imageViewerProps;
exports.ElImageViewer = ElImageViewer;
exports["default"] = ElImageViewer;
//# sourceMappingURL=index.js.map


sourcesContent:
import { withInstall } from '@element-plus/utils'

import ImageViewer from './src/image-viewer.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElImageViewer: SFCWithInstall<typeof ImageViewer> =
  withInstall(ImageViewer)
export default ElImageViewer

export * from './src/image-viewer'

names: withInstall ImageViewer


code:
import type { Component, ExtractPropTypes } from 'vue';
import type ImageViewer from './image-viewer.vue';
export declare type ImageViewerAction = 'zoomIn' | 'zoomOut' | 'clockwise' | 'anticlockwise';
export declare const imageViewerProps: {
    readonly urlList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
    readonly zIndex: {
        readonly type: import("vue").PropType<number>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly infinite: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly hideOnClickModal: BooleanConstructor;
    readonly teleported: BooleanConstructor;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
    readonly crossorigin: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
};
export declare type ImageViewerProps = ExtractPropTypes<typeof imageViewerProps>;
export declare const imageViewerEmits: {
    close: () => boolean;
    switch: (index: number) => boolean;
    rotate: (deg: number) => boolean;
};
export declare type ImageViewerEmits = typeof imageViewerEmits;
export interface ImageViewerMode {
    name: string;
    icon: Component;
}
export declare type ImageViewerInstance = InstanceType<typeof ImageViewer>;


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require('../../../utils/index.js');
var runtime = require('../../../utils/vue/props/runtime.js');
var typescript = require('../../../utils/typescript.js');
var types = require('../../../utils/types.js');

const imageViewerProps = runtime.buildProps({
  urlList: {
    type: runtime.definePropType(Array),
    default: () => typescript.mutable([])
  },
  zIndex: {
    type: Number
  },
  initialIndex: {
    type: Number,
    default: 0
  },
  infinite: {
    type: Boolean,
    default: true
  },
  hideOnClickModal: Boolean,
  teleported: Boolean,
  closeOnPressEscape: {
    type: Boolean,
    default: true
  },
  zoomRate: {
    type: Number,
    default: 1.2
  },
  minScale: {
    type: Number,
    default: 0.2
  },
  maxScale: {
    type: Number,
    default: 7
  },
  crossorigin: {
    type: runtime.definePropType(String)
  }
});
const imageViewerEmits = {
  close: () => true,
  switch: (index) => types.isNumber(index),
  rotate: (deg) => types.isNumber(deg)
};

exports.imageViewerEmits = imageViewerEmits;
exports.imageViewerProps = imageViewerProps;
//# sourceMappingURL=image-viewer.js.map


code:
declare function setActiveItem(index: number): void;
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    readonly urlList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
    readonly zIndex: {
        readonly type: import("vue").PropType<number>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly infinite: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly hideOnClickModal: BooleanConstructor;
    readonly teleported: BooleanConstructor;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
    readonly crossorigin: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
}, {
    /**
     * @description manually switch image
     */
    setActiveItem: typeof setActiveItem;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    switch: (index: number) => void;
    rotate: (deg: number) => void;
    close: () => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly urlList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
    readonly zIndex: {
        readonly type: import("vue").PropType<number>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly infinite: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly hideOnClickModal: BooleanConstructor;
    readonly teleported: BooleanConstructor;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
    readonly crossorigin: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
}>> & {
    onClose?: (() => any) | undefined;
    onSwitch?: ((index: number) => any) | undefined;
    onRotate?: ((deg: number) => any) | undefined;
}, {
    readonly infinite: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly teleported: boolean;
    readonly initialIndex: number;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly urlList: string[];
    readonly zoomRate: number;
    readonly minScale: number;
    readonly maxScale: number;
    readonly hideOnClickModal: boolean;
}>, {
    default?(_: {}): any;
}>;
export default _default;
declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var core = require('@vueuse/core');
var lodashUnified = require('lodash-unified');
require('../../../hooks/index.js');
require('../../../constants/index.js');
require('../../../utils/index.js');
var index$3 = require('../../teleport/index.js');
var index$4 = require('../../icon/index.js');
var iconsVue = require('@element-plus/icons-vue');
var imageViewer = require('./image-viewer.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
var index = require('../../../hooks/use-locale/index.js');
var index$1 = require('../../../hooks/use-namespace/index.js');
var index$2 = require('../../../hooks/use-z-index/index.js');
var aria = require('../../../constants/aria.js');
var objects = require('../../../utils/objects.js');

const __default__ = vue.defineComponent({
  name: "ElImageViewer"
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...__default__,
  props: imageViewer.imageViewerProps,
  emits: imageViewer.imageViewerEmits,
  setup(__props, { expose, emit }) {
    var _a;
    const props = __props;
    const modes = {
      CONTAIN: {
        name: "contain",
        icon: vue.markRaw(iconsVue.FullScreen)
      },
      ORIGINAL: {
        name: "original",
        icon: vue.markRaw(iconsVue.ScaleToOriginal)
      }
    };
    const { t } = index.useLocale();
    const ns = index$1.useNamespace("image-viewer");
    const { nextZIndex } = index$2.useZIndex();
    const wrapper = vue.ref();
    const imgRefs = vue.ref([]);
    const scopeEventListener = vue.effectScope();
    const loading = vue.ref(true);
    const activeIndex = vue.ref(props.initialIndex);
    const mode = vue.shallowRef(modes.CONTAIN);
    const transform = vue.ref({
      scale: 1,
      deg: 0,
      offsetX: 0,
      offsetY: 0,
      enableTransition: false
    });
    const zIndex = vue.ref((_a = props.zIndex) != null ? _a : nextZIndex());
    const isSingle = vue.computed(() => {
      const { urlList } = props;
      return urlList.length <= 1;
    });
    const isFirst = vue.computed(() => {
      return activeIndex.value === 0;
    });
    const isLast = vue.computed(() => {
      return activeIndex.value === props.urlList.length - 1;
    });
    const currentImg = vue.computed(() => {
      return props.urlList[activeIndex.value];
    });
    const arrowPrevKls = vue.computed(() => [
      ns.e("btn"),
      ns.e("prev"),
      ns.is("disabled", !props.infinite && isFirst.value)
    ]);
    const arrowNextKls = vue.computed(() => [
      ns.e("btn"),
      ns.e("next"),
      ns.is("disabled", !props.infinite && isLast.value)
    ]);
    const imgStyle = vue.computed(() => {
      const { scale, deg, offsetX, offsetY, enableTransition } = transform.value;
      let translateX = offsetX / scale;
      let translateY = offsetY / scale;
      const radian = deg * Math.PI / 180;
      const cosRadian = Math.cos(radian);
      const sinRadian = Math.sin(radian);
      translateX = translateX * cosRadian + translateY * sinRadian;
      translateY = translateY * cosRadian - offsetX / scale * sinRadian;
      const style = {
        transform: `scale(${scale}) rotate(${deg}deg) translate(${translateX}px, ${translateY}px)`,
        transition: enableTransition ? "transform .3s" : ""
      };
      if (mode.value.name === modes.CONTAIN.name) {
        style.maxWidth = style.maxHeight = "100%";
      }
      return style;
    });
    function hide() {
      unregisterEventListener();
      emit("close");
    }
    function registerEventListener() {
      const keydownHandler = lodashUnified.throttle((e) => {
        switch (e.code) {
          case aria.EVENT_CODE.esc:
            props.closeOnPressEscape && hide();
            break;
          case aria.EVENT_CODE.space:
            toggleMode();
            break;
          case aria.EVENT_CODE.left:
            prev();
            break;
          case aria.EVENT_CODE.up:
            handleActions("zoomIn");
            break;
          case aria.EVENT_CODE.right:
            next();
            break;
          case aria.EVENT_CODE.down:
            handleActions("zoomOut");
            break;
        }
      });
      const mousewheelHandler = lodashUnified.throttle((e) => {
        const delta = e.deltaY || e.deltaX;
        handleActions(delta < 0 ? "zoomIn" : "zoomOut", {
          zoomRate: props.zoomRate,
          enableTransition: false
        });
      });
      scopeEventListener.run(() => {
        core.useEventListener(document, "keydown", keydownHandler);
        core.useEventListener(document, "wheel", mousewheelHandler);
      });
    }
    function unregisterEventListener() {
      scopeEventListener.stop();
    }
    function handleImgLoad() {
      loading.value = false;
    }
    function handleImgError(e) {
      loading.value = false;
      e.target.alt = t("el.image.error");
    }
    function handleMouseDown(e) {
      if (loading.value || e.button !== 0 || !wrapper.value)
        return;
      transform.value.enableTransition = false;
      const { offsetX, offsetY } = transform.value;
      const startX = e.pageX;
      const startY = e.pageY;
      const dragHandler = lodashUnified.throttle((ev) => {
        transform.value = {
          ...transform.value,
          offsetX: offsetX + ev.pageX - startX,
          offsetY: offsetY + ev.pageY - startY
        };
      });
      const removeMousemove = core.useEventListener(document, "mousemove", dragHandler);
      core.useEventListener(document, "mouseup", () => {
        removeMousemove();
      });
      e.preventDefault();
    }
    function reset() {
      transform.value = {
        scale: 1,
        deg: 0,
        offsetX: 0,
        offsetY: 0,
        enableTransition: false
      };
    }
    function toggleMode() {
      if (loading.value)
        return;
      const modeNames = objects.keysOf(modes);
      const modeValues = Object.values(modes);
      const currentMode = mode.value.name;
      const index = modeValues.findIndex((i) => i.name === currentMode);
      const nextIndex = (index + 1) % modeNames.length;
      mode.value = modes[modeNames[nextIndex]];
      reset();
    }
    function setActiveItem(index) {
      const len = props.urlList.length;
      activeIndex.value = (index + len) % len;
    }
    function prev() {
      if (isFirst.value && !props.infinite)
        return;
      setActiveItem(activeIndex.value - 1);
    }
    function next() {
      if (isLast.value && !props.infinite)
        return;
      setActiveItem(activeIndex.value + 1);
    }
    function handleActions(action, options = {}) {
      if (loading.value)
        return;
      const { minScale, maxScale } = props;
      const { zoomRate, rotateDeg, enableTransition } = {
        zoomRate: props.zoomRate,
        rotateDeg: 90,
        enableTransition: true,
        ...options
      };
      switch (action) {
        case "zoomOut":
          if (transform.value.scale > minScale) {
            transform.value.scale = Number.parseFloat((transform.value.scale / zoomRate).toFixed(3));
          }
          break;
        case "zoomIn":
          if (transform.value.scale < maxScale) {
            transform.value.scale = Number.parseFloat((transform.value.scale * zoomRate).toFixed(3));
          }
          break;
        case "clockwise":
          transform.value.deg += rotateDeg;
          emit("rotate", transform.value.deg);
          break;
        case "anticlockwise":
          transform.value.deg -= rotateDeg;
          emit("rotate", transform.value.deg);
          break;
      }
      transform.value.enableTransition = enableTransition;
    }
    vue.watch(currentImg, () => {
      vue.nextTick(() => {
        const $img = imgRefs.value[0];
        if (!($img == null ? void 0 : $img.complete)) {
          loading.value = true;
        }
      });
    });
    vue.watch(activeIndex, (val) => {
      reset();
      emit("switch", val);
    });
    vue.onMounted(() => {
      var _a2, _b;
      registerEventListener();
      (_b = (_a2 = wrapper.value) == null ? void 0 : _a2.focus) == null ? void 0 : _b.call(_a2);
    });
    expose({
      setActiveItem
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createBlock(vue.unref(index$3.ElTeleport), {
        to: "body",
        disabled: !_ctx.teleported
      }, {
        default: vue.withCtx(() => [
          vue.createVNode(vue.Transition, {
            name: "viewer-fade",
            appear: ""
          }, {
            default: vue.withCtx(() => [
              vue.createElementVNode("div", {
                ref_key: "wrapper",
                ref: wrapper,
                tabindex: -1,
                class: vue.normalizeClass(vue.unref(ns).e("wrapper")),
                style: vue.normalizeStyle({ zIndex: zIndex.value })
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("mask")),
                  onClick: vue.withModifiers(($event) => _ctx.hideOnClickModal && hide(), ["self"])
                }, null, 10, ["onClick"]),
                vue.createCommentVNode(" CLOSE "),
                vue.createElementVNode("span", {
                  class: vue.normalizeClass([vue.unref(ns).e("btn"), vue.unref(ns).e("close")]),
                  onClick: hide
                }, [
                  vue.createVNode(vue.unref(index$4.ElIcon), null, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(iconsVue.Close))
                    ]),
                    _: 1
                  })
                ], 2),
                vue.createCommentVNode(" ARROW "),
                !vue.unref(isSingle) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(arrowPrevKls)),
                    onClick: prev
                  }, [
                    vue.createVNode(vue.unref(index$4.ElIcon), null, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(iconsVue.ArrowLeft))
                      ]),
                      _: 1
                    })
                  ], 2),
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(arrowNextKls)),
                    onClick: next
                  }, [
                    vue.createVNode(vue.unref(index$4.ElIcon), null, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(iconsVue.ArrowRight))
                      ]),
                      _: 1
                    })
                  ], 2)
                ], 64)) : vue.createCommentVNode("v-if", true),
                vue.createCommentVNode(" ACTIONS "),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([vue.unref(ns).e("btn"), vue.unref(ns).e("actions")])
                }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(ns).e("actions__inner"))
                  }, [
                    vue.createVNode(vue.unref(index$4.ElIcon), {
                      onClick: ($event) => handleActions("zoomOut")
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(iconsVue.ZoomOut))
                      ]),
                      _: 1
                    }, 8, ["onClick"]),
                    vue.createVNode(vue.unref(index$4.ElIcon), {
                      onClick: ($event) => handleActions("zoomIn")
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(iconsVue.ZoomIn))
                      ]),
                      _: 1
                    }, 8, ["onClick"]),
                    vue.createElementVNode("i", {
                      class: vue.normalizeClass(vue.unref(ns).e("actions__divider"))
                    }, null, 2),
                    vue.createVNode(vue.unref(index$4.ElIcon), { onClick: toggleMode }, {
                      default: vue.withCtx(() => [
                        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(mode).icon)))
                      ]),
                      _: 1
                    }),
                    vue.createElementVNode("i", {
                      class: vue.normalizeClass(vue.unref(ns).e("actions__divider"))
                    }, null, 2),
                    vue.createVNode(vue.unref(index$4.ElIcon), {
                      onClick: ($event) => handleActions("anticlockwise")
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(iconsVue.RefreshLeft))
                      ]),
                      _: 1
                    }, 8, ["onClick"]),
                    vue.createVNode(vue.unref(index$4.ElIcon), {
                      onClick: ($event) => handleActions("clockwise")
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(iconsVue.RefreshRight))
                      ]),
                      _: 1
                    }, 8, ["onClick"])
                  ], 2)
                ], 2),
                vue.createCommentVNode(" CANVAS "),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("canvas"))
                }, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.urlList, (url, i) => {
                    return vue.withDirectives((vue.openBlock(), vue.createElementBlock("img", {
                      ref_for: true,
                      ref: (el) => imgRefs.value[i] = el,
                      key: url,
                      src: url,
                      style: vue.normalizeStyle(vue.unref(imgStyle)),
                      class: vue.normalizeClass(vue.unref(ns).e("img")),
                      crossorigin: _ctx.crossorigin,
                      onLoad: handleImgLoad,
                      onError: handleImgError,
                      onMousedown: handleMouseDown
                    }, null, 46, ["src", "crossorigin"])), [
                      [vue.vShow, i === activeIndex.value]
                    ]);
                  }), 128))
                ], 2),
                vue.renderSlot(_ctx.$slots, "default")
              ], 6)
            ]),
            _: 3
          })
        ]),
        _: 3
      }, 8, ["disabled"]);
    };
  }
});
var ImageViewer = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "image-viewer.vue"]]);

exports["default"] = ImageViewer;
//# sourceMappingURL=image-viewer2.js.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-image-viewer.css';


code:
'use strict';

require('../../base/style/css.js');
require('element-plus/theme-chalk/el-image-viewer.css');

//# sourceMappingURL=css.js.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/image-viewer.scss';


code:
'use strict';

require('../../base/style/index.js');
require('element-plus/theme-chalk/src/image-viewer.scss');

//# sourceMappingURL=index.js.map


code:
import Image from './src/image.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElImage: SFCWithInstall<typeof Image>;
export default ElImage;
export * from './src/image';


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require('../../utils/index.js');
var image$1 = require('./src/image.js');
var image = require('./src/image2.js');
var install = require('../../utils/vue/install.js');

const ElImage = install.withInstall(image$1["default"]);

exports.imageEmits = image.imageEmits;
exports.imageProps = image.imageProps;
exports.ElImage = ElImage;
exports["default"] = ElImage;
//# sourceMappingURL=index.js.map


sourcesContent:
import { withInstall } from '@element-plus/utils'

import Image from './src/image.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElImage: SFCWithInstall<typeof Image> = withInstall(Image)
export default ElImage

export * from './src/image'

names: withInstall Image


code:
import type { ExtractPropTypes } from 'vue';
export declare const imageProps: {
    readonly hideOnClickModal: BooleanConstructor;
    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly fit: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "contain" | "fill" | "none" | "cover" | "scale-down", unknown, "", boolean>;
    readonly loading: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "lazy" | "eager", unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly lazy: BooleanConstructor;
    readonly scrollContainer: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | undefined) & {}) | (() => string | HTMLElement | undefined) | ((new (...args: any[]) => (string | HTMLElement | undefined) & {}) | (() => string | HTMLElement | undefined))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly previewSrcList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
    readonly previewTeleported: BooleanConstructor;
    readonly zIndex: {
        readonly type: import("vue").PropType<number>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly infinite: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
    readonly crossorigin: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
};
export declare type ImageProps = ExtractPropTypes<typeof imageProps>;
export declare const imageEmits: {
    load: (evt: Event) => boolean;
    error: (evt: Event) => boolean;
    switch: (val: number) => boolean;
    close: () => boolean;
    show: () => boolean;
};
export declare type ImageEmits = typeof imageEmits;


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var core = require('@vueuse/core');
var lodashUnified = require('lodash-unified');
require('../../../hooks/index.js');
var index$3 = require('../../image-viewer/index.js');
require('../../../utils/index.js');
var image = require('./image2.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
var index = require('../../../hooks/use-locale/index.js');
var index$1 = require('../../../hooks/use-namespace/index.js');
var index$2 = require('../../../hooks/use-attrs/index.js');
var position = require('../../../utils/dom/position.js');
var types = require('../../../utils/types.js');
var shared = require('@vue/shared');
var scroll = require('../../../utils/dom/scroll.js');

const __default__ = vue.defineComponent({
  name: "ElImage",
  inheritAttrs: false
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...__default__,
  props: image.imageProps,
  emits: image.imageEmits,
  setup(__props, { emit }) {
    const props = __props;
    let prevOverflow = "";
    const { t } = index.useLocale();
    const ns = index$1.useNamespace("image");
    const rawAttrs = vue.useAttrs();
    const containerAttrs = vue.computed(() => {
      return lodashUnified.fromPairs(Object.entries(rawAttrs).filter(([key]) => /^(data-|on[A-Z])/i.test(key) || ["id", "style"].includes(key)));
    });
    const imgAttrs = index$2.useAttrs({
      excludeListeners: true,
      excludeKeys: vue.computed(() => {
        return Object.keys(containerAttrs.value);
      })
    });
    const imageSrc = vue.ref();
    const hasLoadError = vue.ref(false);
    const isLoading = vue.ref(true);
    const showViewer = vue.ref(false);
    const container = vue.ref();
    const _scrollContainer = vue.ref();
    const supportLoading = core.isClient && "loading" in HTMLImageElement.prototype;
    let stopScrollListener;
    let stopWheelListener;
    const imageKls = vue.computed(() => [
      ns.e("inner"),
      preview.value && ns.e("preview"),
      isLoading.value && ns.is("loading")
    ]);
    const imageStyle = vue.computed(() => {
      const { fit } = props;
      if (core.isClient && fit) {
        return { objectFit: fit };
      }
      return {};
    });
    const preview = vue.computed(() => {
      const { previewSrcList } = props;
      return Array.isArray(previewSrcList) && previewSrcList.length > 0;
    });
    const imageIndex = vue.computed(() => {
      const { previewSrcList, initialIndex } = props;
      let previewIndex = initialIndex;
      if (initialIndex > previewSrcList.length - 1) {
        previewIndex = 0;
      }
      return previewIndex;
    });
    const isManual = vue.computed(() => {
      if (props.loading === "eager")
        return false;
      return !supportLoading && props.loading === "lazy" || props.lazy;
    });
    const loadImage = () => {
      if (!core.isClient)
        return;
      isLoading.value = true;
      hasLoadError.value = false;
      imageSrc.value = props.src;
    };
    function handleLoad(event) {
      isLoading.value = false;
      hasLoadError.value = false;
      emit("load", event);
    }
    function handleError(event) {
      isLoading.value = false;
      hasLoadError.value = true;
      emit("error", event);
    }
    function handleLazyLoad() {
      if (position.isInContainer(container.value, _scrollContainer.value)) {
        loadImage();
        removeLazyLoadListener();
      }
    }
    const lazyLoadHandler = core.useThrottleFn(handleLazyLoad, 200, true);
    async function addLazyLoadListener() {
      var _a;
      if (!core.isClient)
        return;
      await vue.nextTick();
      const { scrollContainer } = props;
      if (types.isElement(scrollContainer)) {
        _scrollContainer.value = scrollContainer;
      } else if (shared.isString(scrollContainer) && scrollContainer !== "") {
        _scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
      } else if (container.value) {
        _scrollContainer.value = scroll.getScrollContainer(container.value);
      }
      if (_scrollContainer.value) {
        stopScrollListener = core.useEventListener(_scrollContainer, "scroll", lazyLoadHandler);
        setTimeout(() => handleLazyLoad(), 100);
      }
    }
    function removeLazyLoadListener() {
      if (!core.isClient || !_scrollContainer.value || !lazyLoadHandler)
        return;
      stopScrollListener == null ? void 0 : stopScrollListener();
      _scrollContainer.value = void 0;
    }
    function wheelHandler(e) {
      if (!e.ctrlKey)
        return;
      if (e.deltaY < 0) {
        e.preventDefault();
        return false;
      } else if (e.deltaY > 0) {
        e.preventDefault();
        return false;
      }
    }
    function clickHandler() {
      if (!preview.value)
        return;
      stopWheelListener = core.useEventListener("wheel", wheelHandler, {
        passive: false
      });
      prevOverflow = document.body.style.overflow;
      document.body.style.overflow = "hidden";
      showViewer.value = true;
      emit("show");
    }
    function closeViewer() {
      stopWheelListener == null ? void 0 : stopWheelListener();
      document.body.style.overflow = prevOverflow;
      showViewer.value = false;
      emit("close");
    }
    function switchViewer(val) {
      emit("switch", val);
    }
    vue.watch(() => props.src, () => {
      if (isManual.value) {
        isLoading.value = true;
        hasLoadError.value = false;
        removeLazyLoadListener();
        addLazyLoadListener();
      } else {
        loadImage();
      }
    });
    vue.onMounted(() => {
      if (isManual.value) {
        addLazyLoadListener();
      } else {
        loadImage();
      }
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
        ref_key: "container",
        ref: container
      }, vue.unref(containerAttrs), {
        class: [vue.unref(ns).b(), _ctx.$attrs.class]
      }), [
        hasLoadError.value ? vue.renderSlot(_ctx.$slots, "error", { key: 0 }, () => [
          vue.createElementVNode("div", {
            class: vue.normalizeClass(vue.unref(ns).e("error"))
          }, vue.toDisplayString(vue.unref(t)("el.image.error")), 3)
        ]) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
          imageSrc.value !== void 0 ? (vue.openBlock(), vue.createElementBlock("img", vue.mergeProps({ key: 0 }, vue.unref(imgAttrs), {
            src: imageSrc.value,
            loading: _ctx.loading,
            style: vue.unref(imageStyle),
            class: vue.unref(imageKls),
            crossorigin: _ctx.crossorigin,
            onClick: clickHandler,
            onLoad: handleLoad,
            onError: handleError
          }), null, 16, ["src", "loading", "crossorigin"])) : vue.createCommentVNode("v-if", true),
          isLoading.value ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            class: vue.normalizeClass(vue.unref(ns).e("wrapper"))
          }, [
            vue.renderSlot(_ctx.$slots, "placeholder", {}, () => [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("placeholder"))
              }, null, 2)
            ])
          ], 2)) : vue.createCommentVNode("v-if", true)
        ], 64)),
        vue.unref(preview) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
          showViewer.value ? (vue.openBlock(), vue.createBlock(vue.unref(index$3.ElImageViewer), {
            key: 0,
            "z-index": _ctx.zIndex,
            "initial-index": vue.unref(imageIndex),
            infinite: _ctx.infinite,
            "zoom-rate": _ctx.zoomRate,
            "min-scale": _ctx.minScale,
            "max-scale": _ctx.maxScale,
            "url-list": _ctx.previewSrcList,
            crossorigin: _ctx.crossorigin,
            "hide-on-click-modal": _ctx.hideOnClickModal,
            teleported: _ctx.previewTeleported,
            "close-on-press-escape": _ctx.closeOnPressEscape,
            onClose: closeViewer,
            onSwitch: switchViewer
          }, {
            default: vue.withCtx(() => [
              _ctx.$slots.viewer ? (vue.openBlock(), vue.createElementBlock("div", { key: 0 }, [
                vue.renderSlot(_ctx.$slots, "viewer")
              ])) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["z-index", "initial-index", "infinite", "zoom-rate", "min-scale", "max-scale", "url-list", "crossorigin", "hide-on-click-modal", "teleported", "close-on-press-escape"])) : vue.createCommentVNode("v-if", true)
        ], 64)) : vue.createCommentVNode("v-if", true)
      ], 16);
    };
  }
});
var Image = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "image.vue"]]);

exports["default"] = Image;
//# sourceMappingURL=image.js.map


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    readonly hideOnClickModal: BooleanConstructor;
    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly fit: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "contain" | "fill" | "none" | "cover" | "scale-down", unknown, "", boolean>;
    readonly loading: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "lazy" | "eager", unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly lazy: BooleanConstructor;
    readonly scrollContainer: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | undefined) & {}) | (() => string | HTMLElement | undefined) | ((new (...args: any[]) => (string | HTMLElement | undefined) & {}) | (() => string | HTMLElement | undefined))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly previewSrcList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
    readonly previewTeleported: BooleanConstructor;
    readonly zIndex: {
        readonly type: import("vue").PropType<number>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly infinite: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
    readonly crossorigin: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    switch: (val: number) => void;
    show: () => void;
    close: () => void;
    error: (evt: Event) => void;
    load: (evt: Event) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly hideOnClickModal: BooleanConstructor;
    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly fit: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "contain" | "fill" | "none" | "cover" | "scale-down", unknown, "", boolean>;
    readonly loading: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "lazy" | "eager", unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly lazy: BooleanConstructor;
    readonly scrollContainer: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | undefined) & {}) | (() => string | HTMLElement | undefined) | ((new (...args: any[]) => (string | HTMLElement | undefined) & {}) | (() => string | HTMLElement | undefined))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly previewSrcList: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
    readonly previewTeleported: BooleanConstructor;
    readonly zIndex: {
        readonly type: import("vue").PropType<number>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly initialIndex: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly infinite: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly zoomRate: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1.2, boolean>;
    readonly minScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.2, boolean>;
    readonly maxScale: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 7, boolean>;
    readonly crossorigin: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials") | ((new (...args: any[]) => ("" | "anonymous" | "use-credentials") & {}) | (() => "" | "anonymous" | "use-credentials"))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
}>> & {
    onShow?: (() => any) | undefined;
    onLoad?: ((evt: Event) => any) | undefined;
    onError?: ((evt: Event) => any) | undefined;
    onClose?: (() => any) | undefined;
    onSwitch?: ((val: number) => any) | undefined;
}, {
    readonly infinite: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly src: string;
    readonly fit: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "contain" | "fill" | "none" | "cover" | "scale-down", unknown>;
    readonly initialIndex: number;
    readonly lazy: boolean;
    readonly closeOnPressEscape: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly zoomRate: number;
    readonly minScale: number;
    readonly maxScale: number;
    readonly hideOnClickModal: boolean;
    readonly previewSrcList: string[];
    readonly previewTeleported: boolean;
}>, {
    error?(_: {}): any;
    placeholder?(_: {}): any;
    viewer?(_: {}): any;
}>;
export default _default;
declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require('../../../utils/index.js');
var runtime = require('../../../utils/vue/props/runtime.js');
var typescript = require('../../../utils/typescript.js');
var types = require('../../../utils/types.js');

const imageProps = runtime.buildProps({
  hideOnClickModal: Boolean,
  src: {
    type: String,
    default: ""
  },
  fit: {
    type: String,
    values: ["", "contain", "cover", "fill", "none", "scale-down"],
    default: ""
  },
  loading: {
    type: String,
    values: ["eager", "lazy"]
  },
  lazy: Boolean,
  scrollContainer: {
    type: runtime.definePropType([String, Object])
  },
  previewSrcList: {
    type: runtime.definePropType(Array),
    default: () => typescript.mutable([])
  },
  previewTeleported: Boolean,
  zIndex: {
    type: Number
  },
  initialIndex: {
    type: Number,
    default: 0
  },
  infinite: {
    type: Boolean,
    default: true
  },
  closeOnPressEscape: {
    type: Boolean,
    default: true
  },
  zoomRate: {
    type: Number,
    default: 1.2
  },
  minScale: {
    type: Number,
    default: 0.2
  },
  maxScale: {
    type: Number,
    default: 7
  },
  crossorigin: {
    type: runtime.definePropType(String)
  }
});
const imageEmits = {
  load: (evt) => evt instanceof Event,
  error: (evt) => evt instanceof Event,
  switch: (val) => types.isNumber(val),
  close: () => true,
  show: () => true
};

exports.imageEmits = imageEmits;
exports.imageProps = imageProps;
//# sourceMappingURL=image2.js.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-image.css';
import 'element-plus/es/components/image-viewer/style/css';


code:
'use strict';

require('../../base/style/css.js');
require('element-plus/theme-chalk/el-image.css');
require('../../image-viewer/style/css.js');

//# sourceMappingURL=css.js.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/image.scss';
import 'element-plus/es/components/image-viewer/style';


code:
'use strict';

require('../../base/style/index.js');
require('element-plus/theme-chalk/src/image.scss');
require('../../image-viewer/style/index.js');

//# sourceMappingURL=index.js.map


code:
export * from './affix';
export * from './alert';
export * from './autocomplete';
export * from './avatar';
export * from './backtop';
export * from './badge';
export * from './breadcrumb';
export * from './button';
export * from './calendar';
export * from './card';
export * from './carousel';
export * from './cascader';
export * from './cascader-panel';
export * from './check-tag';
export * from './checkbox';
export * from './col';
export * from './collapse';
export * from './collapse-transition';
export * from './color-picker';
export * from './config-provider';
export * from './container';
export * from './countdown';
export * from './date-picker';
export * from './descriptions';
export * from './dialog';
export * from './divider';
export * from './drawer';
export * from './dropdown';
export * from './empty';
export * from './form';
export * from './icon';
export * from './image';
export * from './image-viewer';
export * from './input';
export * from './input-number';
export * from './link';
export * from './menu';
export * from './overlay';
export * from './page-header';
export * from './pagination';
export * from './popconfirm';
export * from './popper';
export * from './progress';
export * from './radio';
export * from './rate';
export * from './result';
export * from './row';
export * from './scrollbar';
export * from './select';
export * from './select-v2';
export * from './skeleton';
export * from './slider';
export * from './space';
export * from './statistic';
export * from './steps';
export * from './switch';
export * from './table';
export * from './table-v2';
export * from './tabs';
export * from './tag';
export * from './text';
export * from './time-picker';
export * from './time-select';
export * from './timeline';
export * from './tooltip';
export * from './transfer';
export * from './tree';
export * from './tree-select';
export * from './tree-v2';
export * from './upload';
export * from './virtual-list';
export * from './watermark';
export * from './tour';
export * from './anchor';
export * from './segmented';
export * from './mention';
export * from './infinite-scroll';
export * from './loading';
export * from './message';
export * from './message-box';
export * from './notification';
export * from './popover';


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var index = require('./affix/index.js');
var index$1 = require('./alert/index.js');
var index$2 = require('./autocomplete/index.js');
var index$3 = require('./avatar/index.js');
var index$4 = require('./backtop/index.js');
var index$5 = require('./badge/index.js');
var index$6 = require('./breadcrumb/index.js');
var index$7 = require('./button/index.js');
var index$8 = require('./calendar/index.js');
var index$9 = require('./card/index.js');
var index$a = require('./carousel/index.js');
var index$b = require('./cascader/index.js');
var index$c = require('./cascader-panel/index.js');
var index$d = require('./check-tag/index.js');
var index$e = require('./checkbox/index.js');
var index$f = require('./col/index.js');
var index$g = require('./collapse/index.js');
var index$h = require('./collapse-transition/index.js');
var index$i = require('./color-picker/index.js');
var index$j = require('./config-provider/index.js');
var index$k = require('./container/index.js');
var index$l = require('./countdown/index.js');
var index$m = require('./date-picker/index.js');
var index$n = require('./descriptions/index.js');
var index$o = require('./dialog/index.js');
var index$p = require('./divider/index.js');
var index$q = require('./drawer/index.js');
var index$r = require('./dropdown/index.js');
var index$s = require('./empty/index.js');
var index$t = require('./form/index.js');
var index$u = require('./icon/index.js');
var index$v = require('./image/index.js');
var index$w = require('./image-viewer/index.js');
var index$x = require('./input/index.js');
var index$y = require('./input-number/index.js');
var index$z = require('./link/index.js');
var index$A = require('./menu/index.js');
var index$B = require('./overlay/index.js');
var index$C = require('./page-header/index.js');
var index$D = require('./pagination/index.js');
var index$E = require('./popconfirm/index.js');
var index$F = require('./popper/index.js');
var index$G = require('./progress/index.js');
var index$H = require('./radio/index.js');
var index$I = require('./rate/index.js');
var index$J = require('./result/index.js');
var index$K = require('./row/index.js');
var index$L = require('./scrollbar/index.js');
var index$M = require('./select/index.js');
var index$N = require('./select-v2/index.js');
var index$O = require('./skeleton/index.js');
var index$P = require('./slider/index.js');
var index$Q = require('./space/index.js');
var index$R = require('./statistic/index.js');
var index$S = require('./steps/index.js');
var index$T = require('./switch/index.js');
var index$U = require('./table/index.js');
var index$V = require('./table-v2/index.js');
var index$W = require('./tabs/index.js');
var index$X = require('./tag/index.js');
var index$Y = require('./text/index.js');
var index$Z = require('./time-picker/index.js');
var index$_ = require('./time-select/index.js');
var index$$ = require('./timeline/index.js');
var index$10 = require('./tooltip/index.js');
var index$11 = require('./transfer/index.js');
var index$12 = require('./tree/index.js');
var index$13 = require('./tree-select/index.js');
var index$14 = require('./tree-v2/index.js');
var index$15 = require('./upload/index.js');
require('./virtual-list/index.js');
var index$16 = require('./watermark/index.js');
var index$17 = require('./tour/index.js');
var index$18 = require('./anchor/index.js');
var index$19 = require('./segmented/index.js');
var index$1a = require('./mention/index.js');
var index$1b = require('./infinite-scroll/index.js');
var index$1c = require('./loading/index.js');
var index$1d = require('./message/index.js');
var index$1e = require('./message-box/index.js');
var index$1f = require('./notification/index.js');
var index$1g = require('./popover/index.js');
var affix = require('./affix/src/affix.js');
var alert = require('./alert/src/alert.js');
var autocomplete = require('./autocomplete/src/autocomplete.js');
var avatar = require('./avatar/src/avatar.js');
var backtop = require('./backtop/src/backtop2.js');
var badge = require('./badge/src/badge.js');
var breadcrumb = require('./breadcrumb/src/breadcrumb.js');
var breadcrumbItem = require('./breadcrumb/src/breadcrumb-item.js');
var constants = require('./breadcrumb/src/constants.js');
var button = require('./button/src/button.js');
var constants$1 = require('./button/src/constants.js');
var calendar = require('./calendar/src/calendar.js');
var card = require('./card/src/card.js');
var carousel = require('./carousel/src/carousel.js');
var carouselItem = require('./carousel/src/carousel-item.js');
var constants$2 = require('./carousel/src/constants.js');
var cascader = require('./cascader/src/cascader.js');
var types = require('./cascader-panel/src/types.js');
var config = require('./cascader-panel/src/config.js');
var checkTag = require('./check-tag/src/check-tag.js');
var checkboxGroup = require('./checkbox/src/checkbox-group.js');
var checkbox = require('./checkbox/src/checkbox.js');
var constants$3 = require('./checkbox/src/constants.js');
var col = require('./col/src/col.js');
var collapse = require('./collapse/src/collapse.js');
var collapseItem = require('./collapse/src/collapse-item.js');
var constants$4 = require('./collapse/src/constants.js');
var colorPicker = require('./color-picker/src/color-picker.js');
var configProvider = require('./config-provider/src/config-provider.js');
var configProviderProps = require('./config-provider/src/config-provider-props.js');
var constants$5 = require('./config-provider/src/constants.js');
var useGlobalConfig = require('./config-provider/src/hooks/use-global-config.js');
var countdown = require('./countdown/src/countdown.js');
var constants$6 = require('./date-picker/src/constants.js');
var datePicker = require('./date-picker/src/props/date-picker.js');
var description = require('./descriptions/src/description.js');
var descriptionItem = require('./descriptions/src/description-item.js');
var useDialog = require('./dialog/src/use-dialog.js');
var dialog = require('./dialog/src/dialog.js');
var constants$7 = require('./dialog/src/constants.js');
var divider = require('./divider/src/divider.js');
var drawer = require('./drawer/src/drawer.js');
var dropdown = require('./dropdown/src/dropdown.js');
var tokens = require('./dropdown/src/tokens.js');
var empty = require('./empty/src/empty.js');
var form = require('./form/src/form.js');
var formItem = require('./form/src/form-item.js');
var constants$8 = require('./form/src/constants.js');
var useFormCommonProps = require('./form/src/hooks/use-form-common-props.js');
var useFormItem = require('./form/src/hooks/use-form-item.js');
var icon = require('./icon/src/icon.js');
var image = require('./image/src/image2.js');
var imageViewer = require('./image-viewer/src/image-viewer.js');
var input = require('./input/src/input.js');
var inputNumber = require('./input-number/src/input-number.js');
var link = require('./link/src/link.js');
var menu = require('./menu/src/menu.js');
var menuItem = require('./menu/src/menu-item.js');
var menuItemGroup = require('./menu/src/menu-item-group.js');
var subMenu = require('./menu/src/sub-menu.js');
var overlay = require('./overlay/src/overlay.js');
var pageHeader = require('./page-header/src/page-header.js');
var pagination = require('./pagination/src/pagination.js');
var constants$9 = require('./pagination/src/constants.js');
var popconfirm = require('./popconfirm/src/popconfirm.js');
var popper = require('./popper/src/popper.js');
var trigger$1 = require('./popper/src/trigger.js');
var content$1 = require('./popper/src/content.js');
var arrow$1 = require('./popper/src/arrow.js');
var constants$a = require('./popper/src/constants.js');
var arrow = require('./popper/src/arrow2.js');
var trigger = require('./popper/src/trigger2.js');
var content = require('./popper/src/content2.js');
var progress = require('./progress/src/progress.js');
var radio = require('./radio/src/radio.js');
var radioGroup = require('./radio/src/radio-group.js');
var radioButton = require('./radio/src/radio-button.js');
var constants$b = require('./radio/src/constants.js');
var rate = require('./rate/src/rate.js');
var result = require('./result/src/result.js');
var row = require('./row/src/row.js');
var constants$c = require('./row/src/constants.js');
var util = require('./scrollbar/src/util.js');
var scrollbar = require('./scrollbar/src/scrollbar.js');
var thumb = require('./scrollbar/src/thumb.js');
var constants$d = require('./scrollbar/src/constants.js');
var token = require('./select/src/token.js');
var token$1 = require('./select-v2/src/token.js');
var skeleton = require('./skeleton/src/skeleton.js');
var skeletonItem = require('./skeleton/src/skeleton-item.js');
var slider = require('./slider/src/slider.js');
var constants$e = require('./slider/src/constants.js');
var space = require('./space/src/space.js');
var item = require('./space/src/item.js');
var useSpace = require('./space/src/use-space.js');
var statistic = require('./statistic/src/statistic.js');
var item$1 = require('./steps/src/item.js');
var steps = require('./steps/src/steps.js');
var _switch = require('./switch/src/switch.js');
var constants$f = require('./table-v2/src/constants.js');
var tableV2 = require('./table-v2/src/table-v2.js');
var _private = require('./table-v2/src/private.js');
var autoResizer = require('./table-v2/src/auto-resizer.js');
var table = require('./table-v2/src/table.js');
var row$1 = require('./table-v2/src/row.js');
var tabs = require('./tabs/src/tabs.js');
var tabBar = require('./tabs/src/tab-bar.js');
var tabNav = require('./tabs/src/tab-nav.js');
var tabPane = require('./tabs/src/tab-pane.js');
var constants$g = require('./tabs/src/constants.js');
var tag = require('./tag/src/tag.js');
var text = require('./text/src/text.js');
var utils = require('./time-picker/src/utils.js');
var constants$h = require('./time-picker/src/constants.js');
var props = require('./time-picker/src/common/props.js');
var picker = require('./time-picker/src/common/picker.js');
var panelTimePick = require('./time-picker/src/time-picker-com/panel-time-pick.js');
var timeSelect = require('./time-select/src/time-select.js');
var timelineItem = require('./timeline/src/timeline-item.js');
var tooltip = require('./tooltip/src/tooltip.js');
var trigger$2 = require('./tooltip/src/trigger.js');
var content$2 = require('./tooltip/src/content.js');
var constants$i = require('./tooltip/src/constants.js');
var transfer = require('./transfer/src/transfer2.js');
var upload = require('./upload/src/upload.js');
var uploadContent = require('./upload/src/upload-content2.js');
var uploadList = require('./upload/src/upload-list.js');
var uploadDragger = require('./upload/src/upload-dragger.js');
var constants$j = require('./upload/src/constants.js');
var fixedSizeList = require('./virtual-list/src/components/fixed-size-list.js');
var dynamicSizeList = require('./virtual-list/src/components/dynamic-size-list.js');
var fixedSizeGrid = require('./virtual-list/src/components/fixed-size-grid.js');
var dynamicSizeGrid = require('./virtual-list/src/components/dynamic-size-grid.js');
var props$1 = require('./virtual-list/src/props.js');
var watermark = require('./watermark/src/watermark.js');
var tour = require('./tour/src/tour.js');
var step = require('./tour/src/step.js');
var content$3 = require('./tour/src/content.js');
var anchor = require('./anchor/src/anchor.js');
var segmented = require('./segmented/src/segmented.js');
var mention = require('./mention/src/mention.js');
var directive = require('./loading/src/directive.js');
var service = require('./loading/src/service.js');
var message = require('./message/src/message.js');
var notification = require('./notification/src/notification.js');
var popover = require('./popover/src/popover.js');

exports.ElAffix = index.ElAffix;
exports.ElAlert = index$1.ElAlert;
exports.ElAutocomplete = index$2.ElAutocomplete;
exports.ElAvatar = index$3.ElAvatar;
exports.ElBacktop = index$4.ElBacktop;
exports.ElBadge = index$5.ElBadge;
exports.ElBreadcrumb = index$6.ElBreadcrumb;
exports.ElBreadcrumbItem = index$6.ElBreadcrumbItem;
exports.ElButton = index$7.ElButton;
exports.ElButtonGroup = index$7.ElButtonGroup;
exports.ElCalendar = index$8.ElCalendar;
exports.ElCard = index$9.ElCard;
exports.ElCarousel = index$a.ElCarousel;
exports.ElCarouselItem = index$a.ElCarouselItem;
exports.ElCascader = index$b.ElCascader;
exports.ElCascaderPanel = index$c.ElCascaderPanel;
exports.ElCheckTag = index$d.ElCheckTag;
exports.ElCheckbox = index$e.ElCheckbox;
exports.ElCheckboxButton = index$e.ElCheckboxButton;
exports.ElCheckboxGroup = index$e.ElCheckboxGroup;
exports.ElCol = index$f.ElCol;
exports.ElCollapse = index$g.ElCollapse;
exports.ElCollapseItem = index$g.ElCollapseItem;
exports.ElCollapseTransition = index$h.ElCollapseTransition;
exports.ElColorPicker = index$i.ElColorPicker;
exports.ElConfigProvider = index$j.ElConfigProvider;
exports.ElAside = index$k.ElAside;
exports.ElContainer = index$k.ElContainer;
exports.ElFooter = index$k.ElFooter;
exports.ElHeader = index$k.ElHeader;
exports.ElMain = index$k.ElMain;
exports.ElCountdown = index$l.ElCountdown;
exports.ElDatePicker = index$m.ElDatePicker;
exports.ElDescriptions = index$n.ElDescriptions;
exports.ElDescriptionsItem = index$n.ElDescriptionsItem;
exports.ElDialog = index$o.ElDialog;
exports.ElDivider = index$p.ElDivider;
exports.ElDrawer = index$q.ElDrawer;
exports.ElDropdown = index$r.ElDropdown;
exports.ElDropdownItem = index$r.ElDropdownItem;
exports.ElDropdownMenu = index$r.ElDropdownMenu;
exports.ElEmpty = index$s.ElEmpty;
exports.ElForm = index$t.ElForm;
exports.ElFormItem = index$t.ElFormItem;
exports.ElIcon = index$u.ElIcon;
exports.ElImage = index$v.ElImage;
exports.ElImageViewer = index$w.ElImageViewer;
exports.ElInput = index$x.ElInput;
exports.ElInputNumber = index$y.ElInputNumber;
exports.ElLink = index$z.ElLink;
exports.ElMenu = index$A.ElMenu;
exports.ElMenuItem = index$A.ElMenuItem;
exports.ElMenuItemGroup = index$A.ElMenuItemGroup;
exports.ElSubMenu = index$A.ElSubMenu;
exports.ElOverlay = index$B.ElOverlay;
exports.ElPageHeader = index$C.ElPageHeader;
exports.ElPagination = index$D.ElPagination;
exports.ElPopconfirm = index$E.ElPopconfirm;
exports.ElPopper = index$F.ElPopper;
exports.ElProgress = index$G.ElProgress;
exports.ElRadio = index$H.ElRadio;
exports.ElRadioButton = index$H.ElRadioButton;
exports.ElRadioGroup = index$H.ElRadioGroup;
exports.ElRate = index$I.ElRate;
exports.ElResult = index$J.ElResult;
exports.ElRow = index$K.ElRow;
exports.ElScrollbar = index$L.ElScrollbar;
exports.ElOption = index$M.ElOption;
exports.ElOptionGroup = index$M.ElOptionGroup;
exports.ElSelect = index$M.ElSelect;
exports.ElSelectV2 = index$N.ElSelectV2;
exports.ElSkeleton = index$O.ElSkeleton;
exports.ElSkeletonItem = index$O.ElSkeletonItem;
exports.ElSlider = index$P.ElSlider;
exports.ElSpace = index$Q.ElSpace;
exports.ElStatistic = index$R.ElStatistic;
exports.ElStep = index$S.ElStep;
exports.ElSteps = index$S.ElSteps;
exports.ElSwitch = index$T.ElSwitch;
exports.ElTable = index$U.ElTable;
exports.ElTableColumn = index$U.ElTableColumn;
exports.ElAutoResizer = index$V.ElAutoResizer;
exports.ElTableV2 = index$V.ElTableV2;
exports.ElTabPane = index$W.ElTabPane;
exports.ElTabs = index$W.ElTabs;
exports.ElTag = index$X.ElTag;
exports.ElText = index$Y.ElText;
exports.ElTimePicker = index$Z.ElTimePicker;
exports.ElTimeSelect = index$_.ElTimeSelect;
exports.ElTimeline = index$$.ElTimeline;
exports.ElTimelineItem = index$$.ElTimelineItem;
exports.ElTooltip = index$10.ElTooltip;
exports.ElTransfer = index$11.ElTransfer;
exports.ElTree = index$12.ElTree;
exports.ElTreeSelect = index$13.ElTreeSelect;
exports.ElTreeV2 = index$14.ElTreeV2;
exports.ElUpload = index$15.ElUpload;
exports.ElWatermark = index$16.ElWatermark;
exports.ElTour = index$17.ElTour;
exports.ElTourStep = index$17.ElTourStep;
exports.ElAnchor = index$18.ElAnchor;
exports.ElAnchorLink = index$18.ElAnchorLink;
exports.ElSegmented = index$19.ElSegmented;
exports.ElMention = index$1a.ElMention;
exports.ElInfiniteScroll = index$1b.ElInfiniteScroll;
exports.ElLoading = index$1c.ElLoading;
exports.ElMessage = index$1d.ElMessage;
exports.ElMessageBox = index$1e.ElMessageBox;
exports.ElNotification = index$1f.ElNotification;
exports.ElPopover = index$1g.ElPopover;
exports.ElPopoverDirective = index$1g.ElPopoverDirective;
exports.affixEmits = affix.affixEmits;
exports.affixProps = affix.affixProps;
exports.alertEffects = alert.alertEffects;
exports.alertEmits = alert.alertEmits;
exports.alertProps = alert.alertProps;
exports.autocompleteEmits = autocomplete.autocompleteEmits;
exports.autocompleteProps = autocomplete.autocompleteProps;
exports.avatarEmits = avatar.avatarEmits;
exports.avatarProps = avatar.avatarProps;
exports.backtopEmits = backtop.backtopEmits;
exports.backtopProps = backtop.backtopProps;
exports.badgeProps = badge.badgeProps;
exports.breadcrumbProps = breadcrumb.breadcrumbProps;
exports.breadcrumbItemProps = breadcrumbItem.breadcrumbItemProps;
exports.breadcrumbKey = constants.breadcrumbKey;
exports.buttonEmits = button.buttonEmits;
exports.buttonNativeTypes = button.buttonNativeTypes;
exports.buttonProps = button.buttonProps;
exports.buttonTypes = button.buttonTypes;
exports.buttonGroupContextKey = constants$1.buttonGroupContextKey;
exports.calendarEmits = calendar.calendarEmits;
exports.calendarProps = calendar.calendarProps;
exports.cardProps = card.cardProps;
exports.carouselEmits = carousel.carouselEmits;
exports.carouselProps = carousel.carouselProps;
exports.carouselItemProps = carouselItem.carouselItemProps;
exports.CAROUSEL_ITEM_NAME = constants$2.CAROUSEL_ITEM_NAME;
exports.carouselContextKey = constants$2.carouselContextKey;
exports.cascaderEmits = cascader.cascaderEmits;
exports.cascaderProps = cascader.cascaderProps;
exports.CASCADER_PANEL_INJECTION_KEY = types.CASCADER_PANEL_INJECTION_KEY;
exports.CommonProps = config.CommonProps;
exports.DefaultProps = config.DefaultProps;
exports.useCascaderConfig = config.useCascaderConfig;
exports.checkTagEmits = checkTag.checkTagEmits;
exports.checkTagProps = checkTag.checkTagProps;
exports.checkboxGroupEmits = checkboxGroup.checkboxGroupEmits;
exports.checkboxGroupProps = checkboxGroup.checkboxGroupProps;
exports.checkboxEmits = checkbox.checkboxEmits;
exports.checkboxProps = checkbox.checkboxProps;
exports.checkboxGroupContextKey = constants$3.checkboxGroupContextKey;
exports.colProps = col.colProps;
exports.collapseEmits = collapse.collapseEmits;
exports.collapseProps = collapse.collapseProps;
exports.emitChangeFn = collapse.emitChangeFn;
exports.collapseItemProps = collapseItem.collapseItemProps;
exports.collapseContextKey = constants$4.collapseContextKey;
exports.colorPickerContextKey = colorPicker.colorPickerContextKey;
exports.colorPickerEmits = colorPicker.colorPickerEmits;
exports.colorPickerProps = colorPicker.colorPickerProps;
exports.messageConfig = configProvider.messageConfig;
exports.configProviderProps = configProviderProps.configProviderProps;
exports.configProviderContextKey = constants$5.configProviderContextKey;
exports.provideGlobalConfig = useGlobalConfig.provideGlobalConfig;
exports.useGlobalComponentSettings = useGlobalConfig.useGlobalComponentSettings;
exports.useGlobalConfig = useGlobalConfig.useGlobalConfig;
exports.countdownEmits = countdown.countdownEmits;
exports.countdownProps = countdown.countdownProps;
exports.ROOT_PICKER_INJECTION_KEY = constants$6.ROOT_PICKER_INJECTION_KEY;
exports.datePickerProps = datePicker.datePickerProps;
exports.descriptionProps = description.descriptionProps;
exports.descriptionItemProps = descriptionItem.descriptionItemProps;
exports.useDialog = useDialog.useDialog;
exports.dialogEmits = dialog.dialogEmits;
exports.dialogProps = dialog.dialogProps;
exports.dialogInjectionKey = constants$7.dialogInjectionKey;
exports.dividerProps = divider.dividerProps;
exports.drawerEmits = drawer.drawerEmits;
exports.drawerProps = drawer.drawerProps;
exports.DROPDOWN_COLLECTION_INJECTION_KEY = dropdown.DROPDOWN_COLLECTION_INJECTION_KEY;
exports.DROPDOWN_COLLECTION_ITEM_INJECTION_KEY = dropdown.DROPDOWN_COLLECTION_ITEM_INJECTION_KEY;
exports.ElCollection = dropdown.ElCollection;
exports.ElCollectionItem = dropdown.ElCollectionItem;
exports.FIRST_KEYS = dropdown.FIRST_KEYS;
exports.FIRST_LAST_KEYS = dropdown.FIRST_LAST_KEYS;
exports.LAST_KEYS = dropdown.LAST_KEYS;
exports.dropdownItemProps = dropdown.dropdownItemProps;
exports.dropdownMenuProps = dropdown.dropdownMenuProps;
exports.dropdownProps = dropdown.dropdownProps;
exports.DROPDOWN_INJECTION_KEY = tokens.DROPDOWN_INJECTION_KEY;
exports.emptyProps = empty.emptyProps;
exports.formEmits = form.formEmits;
exports.formMetaProps = form.formMetaProps;
exports.formProps = form.formProps;
exports.formItemProps = formItem.formItemProps;
exports.formItemValidateStates = formItem.formItemValidateStates;
exports.formContextKey = constants$8.formContextKey;
exports.formItemContextKey = constants$8.formItemContextKey;
exports.useDisabled = useFormCommonProps.useDisabled;
exports.useFormDisabled = useFormCommonProps.useFormDisabled;
exports.useFormSize = useFormCommonProps.useFormSize;
exports.useSize = useFormCommonProps.useSize;
exports.useFormItem = useFormItem.useFormItem;
exports.useFormItemInputId = useFormItem.useFormItemInputId;
exports.iconProps = icon.iconProps;
exports.imageEmits = image.imageEmits;
exports.imageProps = image.imageProps;
exports.imageViewerEmits = imageViewer.imageViewerEmits;
exports.imageViewerProps = imageViewer.imageViewerProps;
exports.inputEmits = input.inputEmits;
exports.inputProps = input.inputProps;
exports.inputNumberEmits = inputNumber.inputNumberEmits;
exports.inputNumberProps = inputNumber.inputNumberProps;
exports.linkEmits = link.linkEmits;
exports.linkProps = link.linkProps;
exports.menuEmits = menu.menuEmits;
exports.menuProps = menu.menuProps;
exports.menuItemEmits = menuItem.menuItemEmits;
exports.menuItemProps = menuItem.menuItemProps;
exports.menuItemGroupProps = menuItemGroup.menuItemGroupProps;
exports.subMenuProps = subMenu.subMenuProps;
exports.overlayEmits = overlay.overlayEmits;
exports.overlayProps = overlay.overlayProps;
exports.pageHeaderEmits = pageHeader.pageHeaderEmits;
exports.pageHeaderProps = pageHeader.pageHeaderProps;
exports.paginationEmits = pagination.paginationEmits;
exports.paginationProps = pagination.paginationProps;
exports.elPaginationKey = constants$9.elPaginationKey;
exports.popconfirmEmits = popconfirm.popconfirmEmits;
exports.popconfirmProps = popconfirm.popconfirmProps;
exports.Effect = popper.Effect;
exports.popperProps = popper.popperProps;
exports.roleTypes = popper.roleTypes;
exports.usePopperProps = popper.usePopperProps;
exports.popperTriggerProps = trigger$1.popperTriggerProps;
exports.usePopperTriggerProps = trigger$1.usePopperTriggerProps;
exports.popperContentEmits = content$1.popperContentEmits;
exports.popperContentProps = content$1.popperContentProps;
exports.popperCoreConfigProps = content$1.popperCoreConfigProps;
exports.usePopperContentEmits = content$1.usePopperContentEmits;
exports.usePopperContentProps = content$1.usePopperContentProps;
exports.usePopperCoreConfigProps = content$1.usePopperCoreConfigProps;
exports.popperArrowProps = arrow$1.popperArrowProps;
exports.usePopperArrowProps = arrow$1.usePopperArrowProps;
exports.POPPER_CONTENT_INJECTION_KEY = constants$a.POPPER_CONTENT_INJECTION_KEY;
exports.POPPER_INJECTION_KEY = constants$a.POPPER_INJECTION_KEY;
exports.ElPopperArrow = arrow["default"];
exports.ElPopperTrigger = trigger["default"];
exports.ElPopperContent = content["default"];
exports.progressProps = progress.progressProps;
exports.radioEmits = radio.radioEmits;
exports.radioProps = radio.radioProps;
exports.radioPropsBase = radio.radioPropsBase;
exports.radioGroupEmits = radioGroup.radioGroupEmits;
exports.radioGroupProps = radioGroup.radioGroupProps;
exports.radioButtonProps = radioButton.radioButtonProps;
exports.radioGroupKey = constants$b.radioGroupKey;
exports.rateEmits = rate.rateEmits;
exports.rateProps = rate.rateProps;
exports.IconComponentMap = result.IconComponentMap;
exports.IconMap = result.IconMap;
exports.resultProps = result.resultProps;
exports.RowAlign = row.RowAlign;
exports.RowJustify = row.RowJustify;
exports.rowProps = row.rowProps;
exports.rowContextKey = constants$c.rowContextKey;
exports.BAR_MAP = util.BAR_MAP;
exports.GAP = util.GAP;
exports.renderThumbStyle = util.renderThumbStyle;
exports.scrollbarEmits = scrollbar.scrollbarEmits;
exports.scrollbarProps = scrollbar.scrollbarProps;
exports.thumbProps = thumb.thumbProps;
exports.scrollbarContextKey = constants$d.scrollbarContextKey;
exports.selectGroupKey = token.selectGroupKey;
exports.selectKey = token.selectKey;
exports.selectV2InjectionKey = token$1.selectV2InjectionKey;
exports.skeletonProps = skeleton.skeletonProps;
exports.skeletonItemProps = skeletonItem.skeletonItemProps;
exports.sliderEmits = slider.sliderEmits;
exports.sliderProps = slider.sliderProps;
exports.sliderContextKey = constants$e.sliderContextKey;
exports.spaceProps = space.spaceProps;
exports.spaceItemProps = item.spaceItemProps;
exports.useSpace = useSpace.useSpace;
exports.statisticProps = statistic.statisticProps;
exports.stepProps = item$1.stepProps;
exports.stepsEmits = steps.stepsEmits;
exports.stepsProps = steps.stepsProps;
exports.switchEmits = _switch.switchEmits;
exports.switchProps = _switch.switchProps;
exports.TableV2Alignment = constants$f.Alignment;
exports.TableV2FixedDir = constants$f.FixedDir;
exports.TableV2SortOrder = constants$f.SortOrder;
exports.TableV2 = tableV2["default"];
exports.TableV2Placeholder = _private.placeholderSign;
exports.autoResizerProps = autoResizer.autoResizerProps;
exports.tableV2Props = table.tableV2Props;
exports.tableV2RowProps = row$1.tableV2RowProps;
exports.tabsEmits = tabs.tabsEmits;
exports.tabsProps = tabs.tabsProps;
exports.tabBarProps = tabBar.tabBarProps;
exports.tabNavEmits = tabNav.tabNavEmits;
exports.tabNavProps = tabNav.tabNavProps;
exports.tabPaneProps = tabPane.tabPaneProps;
exports.tabsRootContextKey = constants$g.tabsRootContextKey;
exports.tagEmits = tag.tagEmits;
exports.tagProps = tag.tagProps;
exports.textProps = text.textProps;
exports.buildTimeList = utils.buildTimeList;
exports.dateEquals = utils.dateEquals;
exports.extractDateFormat = utils.extractDateFormat;
exports.extractTimeFormat = utils.extractTimeFormat;
exports.formatter = utils.formatter;
exports.makeList = utils.makeList;
exports.parseDate = utils.parseDate;
exports.rangeArr = utils.rangeArr;
exports.valueEquals = utils.valueEquals;
exports.DEFAULT_FORMATS_DATE = constants$h.DEFAULT_FORMATS_DATE;
exports.DEFAULT_FORMATS_DATEPICKER = constants$h.DEFAULT_FORMATS_DATEPICKER;
exports.DEFAULT_FORMATS_TIME = constants$h.DEFAULT_FORMATS_TIME;
exports.timeUnits = constants$h.timeUnits;
exports.timePickerDefaultProps = props.timePickerDefaultProps;
exports.CommonPicker = picker["default"];
exports.TimePickPanel = panelTimePick["default"];
exports.timeSelectProps = timeSelect.timeSelectProps;
exports.timelineItemProps = timelineItem.timelineItemProps;
exports.tooltipEmits = tooltip.tooltipEmits;
exports.useTooltipModelToggle = tooltip.useTooltipModelToggle;
exports.useTooltipModelToggleEmits = tooltip.useTooltipModelToggleEmits;
exports.useTooltipModelToggleProps = tooltip.useTooltipModelToggleProps;
exports.useTooltipProps = tooltip.useTooltipProps;
exports.useTooltipTriggerProps = trigger$2.useTooltipTriggerProps;
exports.useTooltipContentProps = content$2.useTooltipContentProps;
exports.TOOLTIP_INJECTION_KEY = constants$i.TOOLTIP_INJECTION_KEY;
exports.LEFT_CHECK_CHANGE_EVENT = transfer.LEFT_CHECK_CHANGE_EVENT;
exports.RIGHT_CHECK_CHANGE_EVENT = transfer.RIGHT_CHECK_CHANGE_EVENT;
exports.transferCheckedChangeFn = transfer.transferCheckedChangeFn;
exports.transferEmits = transfer.transferEmits;
exports.transferProps = transfer.transferProps;
exports.genFileId = upload.genFileId;
exports.uploadBaseProps = upload.uploadBaseProps;
exports.uploadListTypes = upload.uploadListTypes;
exports.uploadProps = upload.uploadProps;
exports.uploadContentProps = uploadContent.uploadContentProps;
exports.uploadListEmits = uploadList.uploadListEmits;
exports.uploadListProps = uploadList.uploadListProps;
exports.uploadDraggerEmits = uploadDragger.uploadDraggerEmits;
exports.uploadDraggerProps = uploadDragger.uploadDraggerProps;
exports.uploadContextKey = constants$j.uploadContextKey;
exports.FixedSizeList = fixedSizeList["default"];
exports.DynamicSizeList = dynamicSizeList["default"];
exports.FixedSizeGrid = fixedSizeGrid["default"];
exports.DynamicSizeGrid = dynamicSizeGrid["default"];
exports.virtualizedGridProps = props$1.virtualizedGridProps;
exports.virtualizedListProps = props$1.virtualizedListProps;
exports.virtualizedProps = props$1.virtualizedProps;
exports.virtualizedScrollbarProps = props$1.virtualizedScrollbarProps;
exports.watermarkProps = watermark.watermarkProps;
exports.tourEmits = tour.tourEmits;
exports.tourProps = tour.tourProps;
exports.tourStepEmits = step.tourStepEmits;
exports.tourStepProps = step.tourStepProps;
exports.tourContentEmits = content$3.tourContentEmits;
exports.tourContentProps = content$3.tourContentProps;
exports.tourPlacements = content$3.tourPlacements;
exports.tourStrategies = content$3.tourStrategies;
exports.anchorEmits = anchor.anchorEmits;
exports.anchorProps = anchor.anchorProps;
exports.segmentedEmits = segmented.segmentedEmits;
exports.segmentedProps = segmented.segmentedProps;
exports.mentionEmits = mention.mentionEmits;
exports.mentionProps = mention.mentionProps;
exports.ElLoadingDirective = directive.vLoading;
exports.vLoading = directive.vLoading;
exports.ElLoadingService = service.Loading;
exports.messageDefaults = message.messageDefaults;
exports.messageEmits = message.messageEmits;
exports.messageProps = message.messageProps;
exports.messageTypes = message.messageTypes;
exports.notificationEmits = notification.notificationEmits;
exports.notificationProps = notification.notificationProps;
exports.notificationTypes = notification.notificationTypes;
exports.popoverEmits = popover.popoverEmits;
exports.popoverProps = popover.popoverProps;
//# sourceMappingURL=index.js.map


code:
import type { SFCWithInstall } from 'element-plus/es/utils';
declare const _InfiniteScroll: SFCWithInstall<import("vue").ObjectDirective<HTMLElement & {
    ElInfiniteScroll: {
        container: HTMLElement | Window;
        containerEl: HTMLElement;
        instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        delay: number;
        lastScrollTop: number;
        cb: () => void;
        onScroll: () => void;
        observer?: MutationObserver | undefined;
    };
}, () => void>>;
export default _InfiniteScroll;
export declare const ElInfiniteScroll: SFCWithInstall<import("vue").ObjectDirective<HTMLElement & {
    ElInfiniteScroll: {
        container: HTMLElement | Window;
        containerEl: HTMLElement;
        instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        delay: number;
        lastScrollTop: number;
        cb: () => void;
        onScroll: () => void;
        observer?: MutationObserver | undefined;
    };
}, () => void>>;


code:
'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var index = require('./src/index.js');

const _InfiniteScroll = index["default"];
_InfiniteScroll.install = (app) => {
  app.directive("InfiniteScroll", _InfiniteScroll);
};
const ElInfiniteScroll = _InfiniteScroll;

exports.ElInfiniteScroll = ElInfiniteScroll;
exports["default"] = _InfiniteScroll;
//# sourceMappingURL=index.js.map


sourcesContent:
import InfiniteScroll from './src'

import type { App } from 'vue'
import type { SFCWithInstall } from '@element-plus/utils'

const _InfiniteScroll = InfiniteScroll as SFCWithInstall<typeof InfiniteScroll>

_InfiniteScroll.install = (app: App) => {
  app.directive('InfiniteScroll', _InfiniteScroll)
}

export default _InfiniteScroll
export const ElInfiniteScroll = _InfiniteScroll


code:
import type { ComponentPublicInstance, ObjectDirective } from 'vue';
export declare const SCOPE = "ElInfiniteScroll";
export declare const CHECK_INTERVAL = 50;
export declare const DEFAULT_DELAY = 200;
export declare const DEFAULT_DISTANCE = 0;
declare type InfiniteScrollCallback = () => void;
declare type InfiniteScrollEl = HTMLElement & {
    [SCOPE]: {
        container: HTMLElement | Window;
        containerEl: HTMLElement;
        instance: ComponentPublicInstance;
        delay: number;
        lastScrollTop: number;
        cb: InfiniteScrollCallback;
        onScroll: () => void;
        observer?: MutationObserver;
    };
};
declare const InfiniteScroll: ObjectDirective<InfiniteScrollEl, InfiniteScrollCallback>;
export default InfiniteScroll;