code:
import { isVNode, Fragment, Text, Comment, openBlock, createBlock, createCommentVNode } from 'vue';
import '../strings.mjs';
import '../types.mjs';
import '../objects.mjs';
import { debugWarn } from '../error.mjs';
import { hasOwn, camelize, isArray } from '@vue/shared';

const SCOPE = "utils/vue/vnode";
var PatchFlags = /* @__PURE__ */ ((PatchFlags2) => {
  PatchFlags2[PatchFlags2["TEXT"] = 1] = "TEXT";
  PatchFlags2[PatchFlags2["CLASS"] = 2] = "CLASS";
  PatchFlags2[PatchFlags2["STYLE"] = 4] = "STYLE";
  PatchFlags2[PatchFlags2["PROPS"] = 8] = "PROPS";
  PatchFlags2[PatchFlags2["FULL_PROPS"] = 16] = "FULL_PROPS";
  PatchFlags2[PatchFlags2["HYDRATE_EVENTS"] = 32] = "HYDRATE_EVENTS";
  PatchFlags2[PatchFlags2["STABLE_FRAGMENT"] = 64] = "STABLE_FRAGMENT";
  PatchFlags2[PatchFlags2["KEYED_FRAGMENT"] = 128] = "KEYED_FRAGMENT";
  PatchFlags2[PatchFlags2["UNKEYED_FRAGMENT"] = 256] = "UNKEYED_FRAGMENT";
  PatchFlags2[PatchFlags2["NEED_PATCH"] = 512] = "NEED_PATCH";
  PatchFlags2[PatchFlags2["DYNAMIC_SLOTS"] = 1024] = "DYNAMIC_SLOTS";
  PatchFlags2[PatchFlags2["HOISTED"] = -1] = "HOISTED";
  PatchFlags2[PatchFlags2["BAIL"] = -2] = "BAIL";
  return PatchFlags2;
})(PatchFlags || {});
function isFragment(node) {
  return isVNode(node) && node.type === Fragment;
}
function isText(node) {
  return isVNode(node) && node.type === Text;
}
function isComment(node) {
  return isVNode(node) && node.type === Comment;
}
const TEMPLATE = "template";
function isTemplate(node) {
  return isVNode(node) && node.type === TEMPLATE;
}
function isValidElementNode(node) {
  return isVNode(node) && !isFragment(node) && !isComment(node);
}
function getChildren(node, depth) {
  if (isComment(node))
    return;
  if (isFragment(node) || isTemplate(node)) {
    return depth > 0 ? getFirstValidNode(node.children, depth - 1) : void 0;
  }
  return node;
}
const getFirstValidNode = (nodes, maxDepth = 3) => {
  if (Array.isArray(nodes)) {
    return getChildren(nodes[0], maxDepth);
  } else {
    return getChildren(nodes, maxDepth);
  }
};
function renderIf(condition, ...args) {
  return condition ? renderBlock(...args) : createCommentVNode("v-if", true);
}
function renderBlock(...args) {
  return openBlock(), createBlock(...args);
}
const getNormalizedProps = (node) => {
  if (!isVNode(node)) {
    debugWarn(SCOPE, "[getNormalizedProps] must be a VNode");
    return {};
  }
  const raw = node.props || {};
  const type = (isVNode(node.type) ? node.type.props : void 0) || {};
  const props = {};
  Object.keys(type).forEach((key) => {
    if (hasOwn(type[key], "default")) {
      props[key] = type[key].default;
    }
  });
  Object.keys(raw).forEach((key) => {
    props[camelize(key)] = raw[key];
  });
  return props;
};
const ensureOnlyChild = (children) => {
  if (!isArray(children) || children.length > 1) {
    throw new Error("expect to receive a single Vue element child");
  }
  return children[0];
};
const flattedChildren = (children) => {
  const vNodes = isArray(children) ? children : [children];
  const result = [];
  vNodes.forEach((child) => {
    var _a;
    if (isArray(child)) {
      result.push(...flattedChildren(child));
    } else if (isVNode(child) && isArray(child.children)) {
      result.push(...flattedChildren(child.children));
    } else {
      result.push(child);
      if (isVNode(child) && ((_a = child.component) == null ? void 0 : _a.subTree)) {
        result.push(...flattedChildren(child.component.subTree));
      }
    }
  });
  return result;
};

export { PatchFlags, ensureOnlyChild, flattedChildren, getFirstValidNode, getNormalizedProps, isComment, isFragment, isTemplate, isText, isValidElementNode, renderBlock, renderIf };
//# sourceMappingURL=vnode.mjs.map


code: export declare const version = "2.8.6";

license: mit


code:
const version = "2.8.6";

export { version };
//# sourceMappingURL=version.mjs.map


code:
declare module 'vue' {
  // GlobalComponents for Volar
  export interface GlobalComponents {
    ElAffix: typeof import('element-plus')['ElAffix']
    ElAlert: typeof import('element-plus')['ElAlert']
    ElAside: typeof import('element-plus')['ElAside']
    ElAutocomplete: typeof import('element-plus')['ElAutocomplete']
    ElAvatar: typeof import('element-plus')['ElAvatar']
    ElAnchor: typeof import('element-plus')['ElAnchor']
    ElAnchorLink: typeof import('element-plus')['ElAnchorLink']
    ElBacktop: typeof import('element-plus')['ElBacktop']
    ElBadge: typeof import('element-plus')['ElBadge']
    ElBreadcrumb: typeof import('element-plus')['ElBreadcrumb']
    ElBreadcrumbItem: typeof import('element-plus')['ElBreadcrumbItem']
    ElButton: typeof import('element-plus')['ElButton']
    ElButtonGroup: typeof import('element-plus')['ElButtonGroup']
    ElCalendar: typeof import('element-plus')['ElCalendar']
    ElCard: typeof import('element-plus')['ElCard']
    ElCarousel: typeof import('element-plus')['ElCarousel']
    ElCarouselItem: typeof import('element-plus')['ElCarouselItem']
    ElCascader: typeof import('element-plus')['ElCascader']
    ElCascaderPanel: typeof import('element-plus')['ElCascaderPanel']
    ElCheckbox: typeof import('element-plus')['ElCheckbox']
    ElCheckboxButton: typeof import('element-plus')['ElCheckboxButton']
    ElCheckboxGroup: typeof import('element-plus')['ElCheckboxGroup']
    ElCol: typeof import('element-plus')['ElCol']
    ElCollapse: typeof import('element-plus')['ElCollapse']
    ElCollapseItem: typeof import('element-plus')['ElCollapseItem']
    ElCollapseTransition: typeof import('element-plus')['ElCollapseTransition']
    ElColorPicker: typeof import('element-plus')['ElColorPicker']
    ElContainer: typeof import('element-plus')['ElContainer']
    ElConfigProvider: typeof import('element-plus')['ElConfigProvider']
    ElDatePicker: typeof import('element-plus')['ElDatePicker']
    ElDialog: typeof import('element-plus')['ElDialog']
    ElDivider: typeof import('element-plus')['ElDivider']
    ElDrawer: typeof import('element-plus')['ElDrawer']
    ElDropdown: typeof import('element-plus')['ElDropdown']
    ElDropdownItem: typeof import('element-plus')['ElDropdownItem']
    ElDropdownMenu: typeof import('element-plus')['ElDropdownMenu']
    ElEmpty: typeof import('element-plus')['ElEmpty']
    ElFooter: typeof import('element-plus')['ElFooter']
    ElForm: typeof import('element-plus')['ElForm']
    ElFormItem: typeof import('element-plus')['ElFormItem']
    ElHeader: typeof import('element-plus')['ElHeader']
    ElIcon: typeof import('element-plus')['ElIcon']
    ElImage: typeof import('element-plus')['ElImage']
    ElImageViewer: typeof import('element-plus')['ElImageViewer']
    ElInput: typeof import('element-plus')['ElInput']
    ElInputNumber: typeof import('element-plus')['ElInputNumber']
    ElLink: typeof import('element-plus')['ElLink']
    ElMain: typeof import('element-plus')['ElMain']
    ElMenu: typeof import('element-plus')['ElMenu']
    ElMenuItem: typeof import('element-plus')['ElMenuItem']
    ElMenuItemGroup: typeof import('element-plus')['ElMenuItemGroup']
    ElOption: typeof import('element-plus')['ElOption']
    ElOptionGroup: typeof import('element-plus')['ElOptionGroup']
    ElPageHeader: typeof import('element-plus')['ElPageHeader']
    ElPagination: typeof import('element-plus')['ElPagination']
    ElPopconfirm: typeof import('element-plus')['ElPopconfirm']
    ElPopper: typeof import('element-plus')['ElPopper']
    ElPopover: typeof import('element-plus')['ElPopover']
    ElProgress: typeof import('element-plus')['ElProgress']
    ElRadio: typeof import('element-plus')['ElRadio']
    ElRadioButton: typeof import('element-plus')['ElRadioButton']
    ElRadioGroup: typeof import('element-plus')['ElRadioGroup']
    ElRate: typeof import('element-plus')['ElRate']
    ElRow: typeof import('element-plus')['ElRow']
    ElScrollbar: typeof import('element-plus')['ElScrollbar']
    ElSelect: typeof import('element-plus')['ElSelect']
    ElSlider: typeof import('element-plus')['ElSlider']
    ElStep: typeof import('element-plus')['ElStep']
    ElSteps: typeof import('element-plus')['ElSteps']
    ElSubMenu: typeof import('element-plus')['ElSubMenu']
    ElSwitch: typeof import('element-plus')['ElSwitch']
    ElTabPane: typeof import('element-plus')['ElTabPane']
    ElTable: typeof import('element-plus')['ElTable']
    ElTableColumn: typeof import('element-plus')['ElTableColumn']
    ElTabs: typeof import('element-plus')['ElTabs']
    ElTag: typeof import('element-plus')['ElTag']
    ElText: typeof import('element-plus')['ElText']
    ElTimePicker: typeof import('element-plus')['ElTimePicker']
    ElTimeSelect: typeof import('element-plus')['ElTimeSelect']
    ElTimeline: typeof import('element-plus')['ElTimeline']
    ElTimelineItem: typeof import('element-plus')['ElTimelineItem']
    ElTooltip: typeof import('element-plus')['ElTooltip']
    ElTransfer: typeof import('element-plus')['ElTransfer']
    ElTree: typeof import('element-plus')['ElTree']
    ElTreeV2: typeof import('element-plus')['ElTreeV2']
    ElTreeSelect: typeof import('element-plus')['ElTreeSelect']
    ElUpload: typeof import('element-plus')['ElUpload']
    ElSpace: typeof import('element-plus')['ElSpace']
    ElSkeleton: typeof import('element-plus')['ElSkeleton']
    ElSkeletonItem: typeof import('element-plus')['ElSkeletonItem']
    ElStatistic: typeof import('element-plus')['ElStatistic']
    ElCountdown: typeof import('element-plus')['ElCountdown']
    ElCheckTag: typeof import('element-plus')['ElCheckTag']
    ElDescriptions: typeof import('element-plus')['ElDescriptions']
    ElDescriptionsItem: typeof import('element-plus')['ElDescriptionsItem']
    ElResult: typeof import('element-plus')['ElResult']
    ElSelectV2: typeof import('element-plus')['ElSelectV2']
    ElWatermark: typeof import('element-plus')['ElWatermark']
    ElTour: typeof import('element-plus')['ElTour']
    ElTourStep: typeof import('element-plus')['ElTourStep']
    ElSegmented: typeof import('element-plus')['ElSegmented']
    ElMention: typeof import('element-plus')['ElMention']
  }

  interface ComponentCustomProperties {
    $message: typeof import('element-plus')['ElMessage']
    $notify: typeof import('element-plus')['ElNotification']
    $msgbox: typeof import('element-plus')['ElMessageBox']
    $messageBox: typeof import('element-plus')['ElMessageBox']
    $alert: typeof import('element-plus')['ElMessageBox']['alert']
    $confirm: typeof import('element-plus')['ElMessageBox']['confirm']
    $prompt: typeof import('element-plus')['ElMessageBox']['prompt']
    $loading: typeof import('element-plus')['ElLoadingService']
  }
}

export {}


code:
'use strict';

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

var _export_sfc = (sfc, props) => {
  const target = sfc.__vccOpts || sfc;
  for (const [key, val] of props) {
    target[key] = val;
  }
  return target;
};

exports["default"] = _export_sfc;
//# sourceMappingURL=plugin-vue_export-helper.js.map


sourcesContent:
export default (sfc, props) => {
  const target = sfc.__vccOpts || sfc;
  for (const [key, val] of props) {
    target[key] = val;
  }
  return target;
}


code:
import type { Plugin } from 'vue';
declare const _default: Plugin[];
export default _default;


code:
'use strict';

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

var index = require('./components/affix/index.js');
var index$1 = require('./components/alert/index.js');
var index$2 = require('./components/autocomplete/index.js');
var index$4 = require('./components/avatar/index.js');
var index$5 = require('./components/backtop/index.js');
var index$6 = require('./components/badge/index.js');
var index$7 = require('./components/breadcrumb/index.js');
var index$8 = require('./components/button/index.js');
var index$9 = require('./components/calendar/index.js');
var index$a = require('./components/card/index.js');
var index$b = require('./components/carousel/index.js');
var index$c = require('./components/cascader/index.js');
var index$d = require('./components/cascader-panel/index.js');
var index$e = require('./components/check-tag/index.js');
var index$f = require('./components/checkbox/index.js');
var index$g = require('./components/col/index.js');
var index$h = require('./components/collapse/index.js');
var index$i = require('./components/collapse-transition/index.js');
var index$j = require('./components/color-picker/index.js');
var index$k = require('./components/config-provider/index.js');
var index$l = require('./components/container/index.js');
var index$m = require('./components/date-picker/index.js');
var index$n = require('./components/descriptions/index.js');
var index$o = require('./components/dialog/index.js');
var index$p = require('./components/divider/index.js');
var index$q = require('./components/drawer/index.js');
var index$r = require('./components/dropdown/index.js');
var index$s = require('./components/empty/index.js');
var index$t = require('./components/form/index.js');
var index$u = require('./components/icon/index.js');
var index$v = require('./components/image/index.js');
var index$w = require('./components/image-viewer/index.js');
var index$x = require('./components/input/index.js');
var index$y = require('./components/input-number/index.js');
var index$z = require('./components/link/index.js');
var index$A = require('./components/menu/index.js');
var index$B = require('./components/page-header/index.js');
var index$C = require('./components/pagination/index.js');
var index$D = require('./components/popconfirm/index.js');
var index$E = require('./components/popover/index.js');
var index$F = require('./components/popper/index.js');
var index$G = require('./components/progress/index.js');
var index$H = require('./components/radio/index.js');
var index$I = require('./components/rate/index.js');
var index$J = require('./components/result/index.js');
var index$K = require('./components/row/index.js');
var index$L = require('./components/scrollbar/index.js');
var index$M = require('./components/select/index.js');
var index$N = require('./components/select-v2/index.js');
var index$O = require('./components/skeleton/index.js');
var index$P = require('./components/slider/index.js');
var index$Q = require('./components/space/index.js');
var index$R = require('./components/statistic/index.js');
var index$S = require('./components/countdown/index.js');
var index$T = require('./components/steps/index.js');
var index$U = require('./components/switch/index.js');
var index$V = require('./components/table/index.js');
var index$3 = require('./components/table-v2/index.js');
var index$W = require('./components/tabs/index.js');
var index$X = require('./components/tag/index.js');
var index$Y = require('./components/text/index.js');
var index$Z = require('./components/time-picker/index.js');
var index$_ = require('./components/time-select/index.js');
var index$$ = require('./components/timeline/index.js');
var index$10 = require('./components/tooltip/index.js');
var index$11 = require('./components/tooltip-v2/index.js');
var index$12 = require('./components/transfer/index.js');
var index$13 = require('./components/tree/index.js');
var index$14 = require('./components/tree-select/index.js');
var index$15 = require('./components/tree-v2/index.js');
var index$16 = require('./components/upload/index.js');
var index$17 = require('./components/watermark/index.js');
var index$18 = require('./components/tour/index.js');
var index$19 = require('./components/anchor/index.js');
var index$1a = require('./components/segmented/index.js');
var index$1b = require('./components/mention/index.js');

var Components = [
  index.ElAffix,
  index$1.ElAlert,
  index$2.ElAutocomplete,
  index$3.ElAutoResizer,
  index$4.ElAvatar,
  index$5.ElBacktop,
  index$6.ElBadge,
  index$7.ElBreadcrumb,
  index$7.ElBreadcrumbItem,
  index$8.ElButton,
  index$8.ElButtonGroup,
  index$9.ElCalendar,
  index$a.ElCard,
  index$b.ElCarousel,
  index$b.ElCarouselItem,
  index$c.ElCascader,
  index$d.ElCascaderPanel,
  index$e.ElCheckTag,
  index$f.ElCheckbox,
  index$f.ElCheckboxButton,
  index$f.ElCheckboxGroup,
  index$g.ElCol,
  index$h.ElCollapse,
  index$h.ElCollapseItem,
  index$i.ElCollapseTransition,
  index$j.ElColorPicker,
  index$k.ElConfigProvider,
  index$l.ElContainer,
  index$l.ElAside,
  index$l.ElFooter,
  index$l.ElHeader,
  index$l.ElMain,
  index$m.ElDatePicker,
  index$n.ElDescriptions,
  index$n.ElDescriptionsItem,
  index$o.ElDialog,
  index$p.ElDivider,
  index$q.ElDrawer,
  index$r.ElDropdown,
  index$r.ElDropdownItem,
  index$r.ElDropdownMenu,
  index$s.ElEmpty,
  index$t.ElForm,
  index$t.ElFormItem,
  index$u.ElIcon,
  index$v.ElImage,
  index$w.ElImageViewer,
  index$x.ElInput,
  index$y.ElInputNumber,
  index$z.ElLink,
  index$A.ElMenu,
  index$A.ElMenuItem,
  index$A.ElMenuItemGroup,
  index$A.ElSubMenu,
  index$B.ElPageHeader,
  index$C.ElPagination,
  index$D.ElPopconfirm,
  index$E.ElPopover,
  index$F.ElPopper,
  index$G.ElProgress,
  index$H.ElRadio,
  index$H.ElRadioButton,
  index$H.ElRadioGroup,
  index$I.ElRate,
  index$J.ElResult,
  index$K.ElRow,
  index$L.ElScrollbar,
  index$M.ElSelect,
  index$M.ElOption,
  index$M.ElOptionGroup,
  index$N.ElSelectV2,
  index$O.ElSkeleton,
  index$O.ElSkeletonItem,
  index$P.ElSlider,
  index$Q.ElSpace,
  index$R.ElStatistic,
  index$S.ElCountdown,
  index$T.ElSteps,
  index$T.ElStep,
  index$U.ElSwitch,
  index$V.ElTable,
  index$V.ElTableColumn,
  index$3.ElTableV2,
  index$W.ElTabs,
  index$W.ElTabPane,
  index$X.ElTag,
  index$Y.ElText,
  index$Z.ElTimePicker,
  index$_.ElTimeSelect,
  index$$.ElTimeline,
  index$$.ElTimelineItem,
  index$10.ElTooltip,
  index$11.ElTooltipV2,
  index$12.ElTransfer,
  index$13.ElTree,
  index$14.ElTreeSelect,
  index$15.ElTreeV2,
  index$16.ElUpload,
  index$17.ElWatermark,
  index$18.ElTour,
  index$18.ElTourStep,
  index$19.ElAnchor,
  index$19.ElAnchorLink,
  index$1a.ElSegmented,
  index$1b.ElMention
];

exports["default"] = Components;
//# sourceMappingURL=component.js.map


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


code:
'use strict';

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

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

const ElAffix = install.withInstall(affix$1["default"]);

exports.affixEmits = affix.affixEmits;
exports.affixProps = affix.affixProps;
exports.ElAffix = ElAffix;
exports["default"] = ElAffix;
//# sourceMappingURL=index.js.map


sourcesContent:
import { withInstall } from '@element-plus/utils'
import Affix from './src/affix.vue'
import type { SFCWithInstall } from '@element-plus/utils'
export const ElAffix: SFCWithInstall<typeof Affix> = withInstall(Affix)
export default ElAffix

export * from './src/affix'

names: withInstall Affix


code:
import type { ExtractPropTypes } from 'vue';
import type { ZIndexProperty } from 'csstype';
import type Affix from './affix.vue';
export declare const affixProps: {
    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ZIndexProperty & {}) | (() => ZIndexProperty) | ((new (...args: any[]) => ZIndexProperty & {}) | (() => ZIndexProperty))[], unknown, unknown, 100, boolean>;
    readonly target: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly position: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom", unknown, "top", boolean>;
};
export declare type AffixProps = ExtractPropTypes<typeof affixProps>;
export declare const affixEmits: {
    scroll: ({ scrollTop, fixed }: {
        scrollTop: number;
        fixed: boolean;
    }) => boolean;
    change: (fixed: boolean) => boolean;
};
export declare type AffixEmits = typeof affixEmits;
export declare type AffixInstance = InstanceType<typeof Affix>;


code:
'use strict';

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

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

const affixProps = runtime.buildProps({
  zIndex: {
    type: runtime.definePropType([Number, String]),
    default: 100
  },
  target: {
    type: String,
    default: ""
  },
  offset: {
    type: Number,
    default: 0
  },
  position: {
    type: String,
    values: ["top", "bottom"],
    default: "top"
  }
});
const affixEmits = {
  scroll: ({ scrollTop, fixed }) => types.isNumber(scrollTop) && types.isBoolean(fixed),
  [event.CHANGE_EVENT]: (fixed) => types.isBoolean(fixed)
};

exports.affixEmits = affixEmits;
exports.affixProps = affixProps;
//# sourceMappingURL=affix.js.map


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty) | ((new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty))[], unknown, unknown, 100, boolean>;
    readonly target: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly position: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom", unknown, "top", boolean>;
}, {
    /** @description update affix status */
    update: () => void;
    /** @description update rootRect info */
    updateRoot: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    scroll: (args_0: {
        scrollTop: number;
        fixed: boolean;
    }) => void;
    change: (fixed: boolean) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty) | ((new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty))[], unknown, unknown, 100, boolean>;
    readonly target: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly position: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom", unknown, "top", boolean>;
}>> & {
    onScroll?: ((args_0: {
        scrollTop: number;
        fixed: boolean;
    }) => any) | undefined;
    onChange?: ((fixed: boolean) => any) | undefined;
}, {
    readonly position: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "bottom", unknown>;
    readonly zIndex: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty) | ((new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty))[], unknown, unknown>;
    readonly offset: number;
    readonly target: string;
}>, {
    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');
require('../../../utils/index.js');
require('../../../hooks/index.js');
var affix = require('./affix.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
var index = require('../../../hooks/use-namespace/index.js');
var style = require('../../../utils/dom/style.js');
var error = require('../../../utils/error.js');
var scroll = require('../../../utils/dom/scroll.js');

const COMPONENT_NAME = "ElAffix";
const __default__ = vue.defineComponent({
  name: COMPONENT_NAME
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...__default__,
  props: affix.affixProps,
  emits: affix.affixEmits,
  setup(__props, { expose, emit }) {
    const props = __props;
    const ns = index.useNamespace("affix");
    const target = vue.shallowRef();
    const root = vue.shallowRef();
    const scrollContainer = vue.shallowRef();
    const { height: windowHeight } = core.useWindowSize();
    const {
      height: rootHeight,
      width: rootWidth,
      top: rootTop,
      bottom: rootBottom,
      update: updateRoot
    } = core.useElementBounding(root, { windowScroll: false });
    const targetRect = core.useElementBounding(target);
    const fixed = vue.ref(false);
    const scrollTop = vue.ref(0);
    const transform = vue.ref(0);
    const rootStyle = vue.computed(() => {
      return {
        height: fixed.value ? `${rootHeight.value}px` : "",
        width: fixed.value ? `${rootWidth.value}px` : ""
      };
    });
    const affixStyle = vue.computed(() => {
      if (!fixed.value)
        return {};
      const offset = props.offset ? style.addUnit(props.offset) : 0;
      return {
        height: `${rootHeight.value}px`,
        width: `${rootWidth.value}px`,
        top: props.position === "top" ? offset : "",
        bottom: props.position === "bottom" ? offset : "",
        transform: transform.value ? `translateY(${transform.value}px)` : "",
        zIndex: props.zIndex
      };
    });
    const update = () => {
      if (!scrollContainer.value)
        return;
      scrollTop.value = scrollContainer.value instanceof Window ? document.documentElement.scrollTop : scrollContainer.value.scrollTop || 0;
      const { position, target: target2, offset } = props;
      const rootHeightOffset = offset + rootHeight.value;
      if (position === "top") {
        if (target2) {
          const difference = targetRect.bottom.value - rootHeightOffset;
          fixed.value = offset > rootTop.value && targetRect.bottom.value > 0;
          transform.value = difference < 0 ? difference : 0;
        } else {
          fixed.value = offset > rootTop.value;
        }
      } else if (target2) {
        const difference = windowHeight.value - targetRect.top.value - rootHeightOffset;
        fixed.value = windowHeight.value - offset < rootBottom.value && windowHeight.value > targetRect.top.value;
        transform.value = difference < 0 ? -difference : 0;
      } else {
        fixed.value = windowHeight.value - offset < rootBottom.value;
      }
    };
    const handleScroll = () => {
      updateRoot();
      emit("scroll", {
        scrollTop: scrollTop.value,
        fixed: fixed.value
      });
    };
    vue.watch(fixed, (val) => emit("change", val));
    vue.onMounted(() => {
      var _a;
      if (props.target) {
        target.value = (_a = document.querySelector(props.target)) != null ? _a : void 0;
        if (!target.value)
          error.throwError(COMPONENT_NAME, `Target does not exist: ${props.target}`);
      } else {
        target.value = document.documentElement;
      }
      scrollContainer.value = scroll.getScrollContainer(root.value, true);
      updateRoot();
    });
    core.useEventListener(scrollContainer, "scroll", handleScroll);
    vue.watchEffect(update);
    expose({
      update,
      updateRoot
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createElementBlock("div", {
        ref_key: "root",
        ref: root,
        class: vue.normalizeClass(vue.unref(ns).b()),
        style: vue.normalizeStyle(vue.unref(rootStyle))
      }, [
        vue.createElementVNode("div", {
          class: vue.normalizeClass({ [vue.unref(ns).m("fixed")]: fixed.value }),
          style: vue.normalizeStyle(vue.unref(affixStyle))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 6)
      ], 6);
    };
  }
});
var Affix = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "affix.vue"]]);

exports["default"] = Affix;
//# sourceMappingURL=affix2.js.map


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


code:
'use strict';

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

//# sourceMappingURL=css.js.map


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


code:
'use strict';

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

//# sourceMappingURL=index.js.map


code:
import Alert from './src/alert.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElAlert: SFCWithInstall<typeof Alert>;
export default ElAlert;
export * from './src/alert';
export type { AlertInstance } from './src/instance';


code:
'use strict';

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

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

const ElAlert = install.withInstall(alert$1["default"]);

exports.alertEffects = alert.alertEffects;
exports.alertEmits = alert.alertEmits;
exports.alertProps = alert.alertProps;
exports.ElAlert = ElAlert;
exports["default"] = ElAlert;
//# sourceMappingURL=index.js.map


sourcesContent:
import { withInstall } from '@element-plus/utils'
import Alert from './src/alert.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElAlert: SFCWithInstall<typeof Alert> = withInstall(Alert)
export default ElAlert

export * from './src/alert'
export type { AlertInstance } from './src/instance'

names: withInstall Alert


code:
import type { ExtractPropTypes } from 'vue';
export declare const alertEffects: readonly ["light", "dark"];
export declare const alertProps: {
    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "success" | "warning" | "info", unknown, "info", boolean>;
    readonly closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly showIcon: BooleanConstructor;
    readonly center: BooleanConstructor;
    readonly effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dark" | "light", unknown, "light", boolean>;
};
export declare type AlertProps = ExtractPropTypes<typeof alertProps>;
export declare const alertEmits: {
    close: (evt: MouseEvent) => boolean;
};
export declare type AlertEmits = typeof alertEmits;


code:
'use strict';

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

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

const alertEffects = ["light", "dark"];
const alertProps = runtime.buildProps({
  title: {
    type: String,
    default: ""
  },
  description: {
    type: String,
    default: ""
  },
  type: {
    type: String,
    values: objects.keysOf(icon.TypeComponentsMap),
    default: "info"
  },
  closable: {
    type: Boolean,
    default: true
  },
  closeText: {
    type: String,
    default: ""
  },
  showIcon: Boolean,
  center: Boolean,
  effect: {
    type: String,
    values: alertEffects,
    default: "light"
  }
});
const alertEmits = {
  close: (evt) => evt instanceof MouseEvent
};

exports.alertEffects = alertEffects;
exports.alertEmits = alertEmits;
exports.alertProps = alertProps;
//# sourceMappingURL=alert.js.map


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "success" | "warning" | "info", unknown, "info", boolean>;
    readonly closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly showIcon: BooleanConstructor;
    readonly center: BooleanConstructor;
    readonly effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dark" | "light", unknown, "light", boolean>;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    close: (evt: MouseEvent) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "success" | "warning" | "info", unknown, "info", boolean>;
    readonly closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly showIcon: BooleanConstructor;
    readonly center: BooleanConstructor;
    readonly effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dark" | "light", unknown, "light", boolean>;
}>> & {
    onClose?: ((evt: MouseEvent) => any) | undefined;
}, {
    readonly title: string;
    readonly center: boolean;
    readonly type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "error" | "success" | "warning" | "info", unknown>;
    readonly description: string;
    readonly effect: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "dark" | "light", unknown>;
    readonly closable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly closeText: string;
    readonly showIcon: boolean;
}>, {
    title?(_: {}): any;
    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 index$1 = require('../../icon/index.js');
require('../../../utils/index.js');
require('../../../hooks/index.js');
var alert = require('./alert.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
var icon = require('../../../utils/vue/icon.js');
var index = require('../../../hooks/use-namespace/index.js');

const __default__ = vue.defineComponent({
  name: "ElAlert"
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...__default__,
  props: alert.alertProps,
  emits: alert.alertEmits,
  setup(__props, { emit }) {
    const props = __props;
    const { Close } = icon.TypeComponents;
    const slots = vue.useSlots();
    const ns = index.useNamespace("alert");
    const visible = vue.ref(true);
    const iconComponent = vue.computed(() => icon.TypeComponentsMap[props.type]);
    const iconClass = vue.computed(() => [
      ns.e("icon"),
      { [ns.is("big")]: !!props.description || !!slots.default }
    ]);
    const withDescription = vue.computed(() => {
      return { "with-description": props.description || slots.default };
    });
    const close = (evt) => {
      visible.value = false;
      emit("close", evt);
    };
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createBlock(vue.Transition, {
        name: vue.unref(ns).b("fade"),
        persisted: ""
      }, {
        default: vue.withCtx(() => [
          vue.withDirectives(vue.createElementVNode("div", {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.type), vue.unref(ns).is("center", _ctx.center), vue.unref(ns).is(_ctx.effect)]),
            role: "alert"
          }, [
            _ctx.showIcon && vue.unref(iconComponent) ? (vue.openBlock(), vue.createBlock(vue.unref(index$1.ElIcon), {
              key: 0,
              class: vue.normalizeClass(vue.unref(iconClass))
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
              ]),
              _: 1
            }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("content"))
            }, [
              _ctx.title || _ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 0,
                class: vue.normalizeClass([vue.unref(ns).e("title"), vue.unref(withDescription)])
              }, [
                vue.renderSlot(_ctx.$slots, "title", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
                ])
              ], 2)) : vue.createCommentVNode("v-if", true),
              _ctx.$slots.default || _ctx.description ? (vue.openBlock(), vue.createElementBlock("p", {
                key: 1,
                class: vue.normalizeClass(vue.unref(ns).e("description"))
              }, [
                vue.renderSlot(_ctx.$slots, "default", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.description), 1)
                ])
              ], 2)) : vue.createCommentVNode("v-if", true),
              _ctx.closable ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
                _ctx.closeText ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  class: vue.normalizeClass([vue.unref(ns).e("close-btn"), vue.unref(ns).is("customed")]),
                  onClick: close
                }, vue.toDisplayString(_ctx.closeText), 3)) : (vue.openBlock(), vue.createBlock(vue.unref(index$1.ElIcon), {
                  key: 1,
                  class: vue.normalizeClass(vue.unref(ns).e("close-btn")),
                  onClick: close
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(Close))
                  ]),
                  _: 1
                }, 8, ["class"]))
              ], 64)) : vue.createCommentVNode("v-if", true)
            ], 2)
          ], 2), [
            [vue.vShow, visible.value]
          ])
        ]),
        _: 3
      }, 8, ["name"]);
    };
  }
});
var Alert = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "alert.vue"]]);

exports["default"] = Alert;
//# sourceMappingURL=alert2.js.map


code:
import type Alert from './alert.vue';
export declare type AlertInstance = InstanceType<typeof Alert>;


code:
'use strict';

//# sourceMappingURL=instance.js.map


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


code:
'use strict';

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

//# sourceMappingURL=css.js.map


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


code:
'use strict';

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

//# sourceMappingURL=index.js.map


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


code:
'use strict';

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

//# sourceMappingURL=css.js.map


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


code:
'use strict';

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

//# sourceMappingURL=index.js.map


code:
import Anchor from './src/anchor.vue';
import AnchorLink from './src/anchor-link.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElAnchor: SFCWithInstall<typeof Anchor> & {
    AnchorLink: typeof AnchorLink;
};
export declare const ElAnchorLink: SFCWithInstall<typeof AnchorLink>;
export default ElAnchor;
export * from './src/anchor';


code:
'use strict';

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

require('../../utils/index.js');
var anchor$1 = require('./src/anchor2.js');
var anchorLink = require('./src/anchor-link2.js');
var anchor = require('./src/anchor.js');
var install = require('../../utils/vue/install.js');

const ElAnchor = install.withInstall(anchor$1["default"], {
  AnchorLink: anchorLink["default"]
});
const ElAnchorLink = install.withNoopInstall(anchorLink["default"]);

exports.anchorEmits = anchor.anchorEmits;
exports.anchorProps = anchor.anchorProps;
exports.ElAnchor = ElAnchor;
exports.ElAnchorLink = ElAnchorLink;
exports["default"] = ElAnchor;
//# sourceMappingURL=index.js.map


sourcesContent:
import { withInstall, withNoopInstall } from '@element-plus/utils'
import Anchor from './src/anchor.vue'
import AnchorLink from './src/anchor-link.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElAnchor: SFCWithInstall<typeof Anchor> & {
  AnchorLink: typeof AnchorLink
} = withInstall(Anchor, {
  AnchorLink,
})
export const ElAnchorLink: SFCWithInstall<typeof AnchorLink> =
  withNoopInstall(AnchorLink)
export default ElAnchor

export * from './src/anchor'

names: withInstall Anchor AnchorLink withNoopInstall


code:
import type { ExtractPropTypes } from 'vue';
export declare const anchorLinkProps: {
    title: StringConstructor;
    href: StringConstructor;
};
export declare type AnchorLinkProps = ExtractPropTypes<typeof anchorLinkProps>;


code:
'use strict';

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

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

const anchorLinkProps = runtime.buildProps({
  title: String,
  href: String
});

exports.anchorLinkProps = anchorLinkProps;
//# sourceMappingURL=anchor-link.js.map


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

import type { ExtractPropTypes } from 'vue'

export const anchorLinkProps = buildProps({
  /**
   * @description the text content of the anchor link
   */
  title: String,
  /**
   * @description The address of the anchor link
   */
  href: String,
})

export type AnchorLinkProps = ExtractPropTypes<typeof anchorLinkProps>


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    title: StringConstructor;
    href: StringConstructor;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    title: StringConstructor;
    href: StringConstructor;
}>>, {}>, {
    default?(_: {}): any;
    "sub-link"?(_: {}): 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 anchorLink = require('./anchor-link.js');
var constants = require('./constants.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');

const __default__ = vue.defineComponent({
  name: "ElAnchorLink"
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...__default__,
  props: anchorLink.anchorLinkProps,
  setup(__props) {
    const props = __props;
    const linkRef = vue.ref(null);
    const {
      ns,
      direction,
      currentAnchor,
      addLink,
      removeLink,
      handleClick: contextHandleClick
    } = vue.inject(constants.anchorKey);
    const cls = vue.computed(() => [
      ns.e("link"),
      ns.is("active", currentAnchor.value === props.href)
    ]);
    const handleClick = (e) => {
      contextHandleClick(e, props.href);
    };
    vue.watch(() => props.href, (val, oldVal) => {
      vue.nextTick(() => {
        if (oldVal)
          removeLink(oldVal);
        if (val) {
          addLink({
            href: val,
            el: linkRef.value
          });
        }
      });
    });
    vue.onMounted(() => {
      const { href } = props;
      if (href) {
        addLink({
          href,
          el: linkRef.value
        });
      }
    });
    vue.onBeforeUnmount(() => {
      const { href } = props;
      if (href) {
        removeLink(href);
      }
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass(vue.unref(ns).e("item"))
      }, [
        vue.createElementVNode("a", {
          ref_key: "linkRef",
          ref: linkRef,
          class: vue.normalizeClass(vue.unref(cls)),
          href: _ctx.href,
          onClick: handleClick
        }, [
          vue.renderSlot(_ctx.$slots, "default", {}, () => [
            vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
          ])
        ], 10, ["href"]),
        _ctx.$slots["sub-link"] && vue.unref(direction) === "vertical" ? (vue.openBlock(), vue.createElementBlock("div", {
          key: 0,
          class: vue.normalizeClass(vue.unref(ns).e("list"))
        }, [
          vue.renderSlot(_ctx.$slots, "sub-link")
        ], 2)) : vue.createCommentVNode("v-if", true)
      ], 2);
    };
  }
});
var AnchorLink = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "anchor-link.vue"]]);

exports["default"] = AnchorLink;
//# sourceMappingURL=anchor-link2.js.map


code:
import type { ExtractPropTypes } from 'vue';
import type Anchor from './anchor.vue';
export declare const anchorProps: {
    container: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null) | ((new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bound: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    marker: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown, string, boolean>;
    direction: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown, string, boolean>;
};
export declare type AnchorProps = ExtractPropTypes<typeof anchorProps>;
export declare type AnchorInstance = InstanceType<typeof Anchor>;
export declare const anchorEmits: {
    change: (href: string) => boolean;
    click: (e: MouseEvent, href?: string) => boolean;
};
export declare type AnchorEmits = typeof anchorEmits;


code:
'use strict';

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

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

const anchorProps = runtime.buildProps({
  container: {
    type: runtime.definePropType([
      String,
      Object
    ])
  },
  offset: {
    type: Number,
    default: 0
  },
  bound: {
    type: Number,
    default: 15
  },
  duration: {
    type: Number,
    default: 300
  },
  marker: {
    type: Boolean,
    default: true
  },
  type: {
    type: runtime.definePropType(String),
    default: "default"
  },
  direction: {
    type: runtime.definePropType(String),
    default: "vertical"
  }
});
const anchorEmits = {
  change: (href) => shared.isString(href),
  click: (e, href) => e instanceof MouseEvent && (shared.isString(href) || types.isUndefined(href))
};

exports.anchorEmits = anchorEmits;
exports.anchorProps = anchorProps;
//# sourceMappingURL=anchor.js.map


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    container: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null) | ((new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bound: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    marker: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown, string, boolean>;
    direction: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown, string, boolean>;
}, {
    scrollTo: (href?: string | undefined) => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    click: (e: MouseEvent, href?: string | undefined) => void;
    change: (href: string) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    container: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null) | ((new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bound: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    marker: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown, string, boolean>;
    direction: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown, string, boolean>;
}>> & {
    onChange?: ((href: string) => any) | undefined;
    onClick?: ((e: MouseEvent, href?: string | undefined) => any) | undefined;
}, {
    marker: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    direction: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown>;
    offset: number;
    type: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown>;
    bound: number;
    duration: number;
}>, {
    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');
require('../../../hooks/index.js');
require('../../../utils/index.js');
var anchor = require('./anchor.js');
var constants = require('./constants.js');
var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
var index = require('../../../hooks/use-namespace/index.js');
var element = require('../../../utils/dom/element.js');
var scroll = require('../../../utils/dom/scroll.js');
var position = require('../../../utils/dom/position.js');
var throttleByRaf = require('../../../utils/throttleByRaf.js');
var types = require('../../../utils/types.js');

const __default__ = vue.defineComponent({
  name: "ElAnchor"
});
const _sfc_main = /* @__PURE__ */ vue.defineComponent({
  ...__default__,
  props: anchor.anchorProps,
  emits: anchor.anchorEmits,
  setup(__props, { expose, emit }) {
    const props = __props;
    const currentAnchor = vue.ref("");
    const anchorRef = vue.ref(null);
    const markerRef = vue.ref(null);
    const containerEl = vue.ref();
    const links = {};
    let isScrolling = false;
    let currentScrollTop = 0;
    const ns = index.useNamespace("anchor");
    const cls = vue.computed(() => [
      ns.b(),
      props.type === "underline" ? ns.m("underline") : "",
      ns.m(props.direction)
    ]);
    const addLink = (state) => {
      links[state.href] = state.el;
    };
    const removeLink = (href) => {
      delete links[href];
    };
    const setCurrentAnchor = (href) => {
      const activeHref = currentAnchor.value;
      if (activeHref !== href) {
        currentAnchor.value = href;
        emit("change", href);
      }
    };
    let clearAnimate = null;
    const scrollToAnchor = (href) => {
      if (!containerEl.value)
        return;
      const target = element.getElement(href);
      if (!target)
        return;
      if (clearAnimate)
        clearAnimate();
      isScrolling = true;
      const scrollEle = scroll.getScrollElement(target, containerEl.value);
      const distance = position.getOffsetTopDistance(target, scrollEle);
      const max = scrollEle.scrollHeight - scrollEle.clientHeight;
      const to = Math.min(distance - props.offset, max);
      clearAnimate = scroll.animateScrollTo(containerEl.value, currentScrollTop, to, props.duration, () => {
        setTimeout(() => {
          isScrolling = false;
        }, 20);
      });
    };
    const scrollTo = (href) => {
      if (href) {
        setCurrentAnchor(href);
        scrollToAnchor(href);
      }
    };
    const handleClick = (e, href) => {
      emit("click", e, href);
      scrollTo(href);
    };
    const handleScroll = throttleByRaf.throttleByRaf(() => {
      if (containerEl.value) {
        currentScrollTop = scroll.getScrollTop(containerEl.value);
      }
      const currentHref = getCurrentHref();
      if (isScrolling || types.isUndefined(currentHref))
        return;
      setCurrentAnchor(currentHref);
    });
    const getCurrentHref = () => {
      if (!containerEl.value)
        return;
      const scrollTop = scroll.getScrollTop(containerEl.value);
      const anchorTopList = [];
      for (const href of Object.keys(links)) {
        const target = element.getElement(href);
        if (!target)
          continue;
        const scrollEle = scroll.getScrollElement(target, containerEl.value);
        const distance = position.getOffsetTopDistance(target, scrollEle);
        anchorTopList.push({
          top: distance - props.offset - props.bound,
          href
        });
      }
      anchorTopList.sort((prev, next) => prev.top - next.top);
      for (let i = 0; i < anchorTopList.length; i++) {
        const item = anchorTopList[i];
        const next = anchorTopList[i + 1];
        if (i === 0 && scrollTop === 0) {
          return "";
        }
        if (item.top <= scrollTop && (!next || next.top > scrollTop)) {
          return item.href;
        }
      }
    };
    const getContainer = () => {
      const el = element.getElement(props.container);
      if (!el || types.isWindow(el)) {
        containerEl.value = window;
      } else {
        containerEl.value = el;
      }
    };
    core.useEventListener(containerEl, "scroll", handleScroll);
    const markerStyle = vue.computed(() => {
      if (!anchorRef.value || !markerRef.value || !currentAnchor.value)
        return {};
      const currentLinkEl = links[currentAnchor.value];
      if (!currentLinkEl)
        return {};
      const anchorRect = anchorRef.value.getBoundingClientRect();
      const markerRect = markerRef.value.getBoundingClientRect();
      const linkRect = currentLinkEl.getBoundingClientRect();
      if (props.direction === "horizontal") {
        const left = linkRect.left - anchorRect.left;
        return {
          left: `${left}px`,
          width: `${linkRect.width}px`,
          opacity: 1
        };
      } else {
        const top = linkRect.top - anchorRect.top + (linkRect.height - markerRect.height) / 2;
        return {
          top: `${top}px`,
          opacity: 1
        };
      }
    });
    vue.onMounted(() => {
      getContainer();
      const hash = decodeURIComponent(window.location.hash);
      const target = element.getElement(hash);
      if (target) {
        scrollTo(hash);
      } else {
        handleScroll();
      }
    });
    vue.watch(() => props.container, () => {
      getContainer();
    });
    vue.provide(constants.anchorKey, {
      ns,
      direction: props.direction,
      currentAnchor,
      addLink,
      removeLink,
      handleClick
    });
    expose({
      scrollTo
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createElementBlock("div", {
        ref_key: "anchorRef",
        ref: anchorRef,
        class: vue.normalizeClass(vue.unref(cls))
      }, [
        _ctx.marker ? (vue.openBlock(), vue.createElementBlock("div", {
          key: 0,
          ref_key: "markerRef",
          ref: markerRef,
          class: vue.normalizeClass(vue.unref(ns).e("marker")),
          style: vue.normalizeStyle(vue.unref(markerStyle))
        }, null, 6)) : vue.createCommentVNode("v-if", true),
        vue.createElementVNode("div", {
          class: vue.normalizeClass(vue.unref(ns).e("list"))
        }, [
          vue.renderSlot(_ctx.$slots, "default")
        ], 2)
      ], 2);
    };
  }
});
var Anchor = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "anchor.vue"]]);

exports["default"] = Anchor;
//# sourceMappingURL=anchor2.js.map


code:
import type { InjectionKey, Ref } from 'vue';
import type { UseNamespaceReturn } from 'element-plus/es/hooks';
export interface AnchorLinkState {
    el: HTMLElement;
    href: string;
}
export interface AnchorContext {
    ns: UseNamespaceReturn;
    direction: string;
    currentAnchor: Ref<string>;
    addLink(state: AnchorLinkState): void;
    removeLink(href: string): void;
    handleClick(e: MouseEvent, href?: string): void;
}
export declare const anchorKey: InjectionKey<AnchorContext>;


code:
'use strict';

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

const anchorKey = Symbol("anchor");

exports.anchorKey = anchorKey;
//# sourceMappingURL=constants.js.map


sourcesContent:
import type { InjectionKey, Ref } from 'vue'
import type { UseNamespaceReturn } from '@element-plus/hooks'

export interface AnchorLinkState {
  el: HTMLElement
  href: string
}

export interface AnchorContext {
  ns: UseNamespaceReturn
  direction: string
  currentAnchor: Ref<string>
  addLink(state: AnchorLinkState): void
  removeLink(href: string): void
  handleClick(e: MouseEvent, href?: string): void
}

export const anchorKey: InjectionKey<AnchorContext> = Symbol('anchor')


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


code:
'use strict';

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

//# sourceMappingURL=css.js.map


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


code:
'use strict';

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

//# sourceMappingURL=index.js.map


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


code:
'use strict';

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

//# sourceMappingURL=css.js.map


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


code:
'use strict';

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

//# sourceMappingURL=index.js.map


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


code:
'use strict';

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

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

const ElAutocomplete = install.withInstall(autocomplete$1["default"]);

exports.autocompleteEmits = autocomplete.autocompleteEmits;
exports.autocompleteProps = autocomplete.autocompleteProps;
exports.ElAutocomplete = ElAutocomplete;
exports["default"] = ElAutocomplete;
//# sourceMappingURL=index.js.map


sourcesContent:
import { withInstall } from '@element-plus/utils'
import Autocomplete from './src/autocomplete.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElAutocomplete: SFCWithInstall<typeof Autocomplete> =
  withInstall(Autocomplete)

export default ElAutocomplete

export * from './src/autocomplete'

names: withInstall Autocomplete


code:
import type { ExtractPropTypes } from 'vue';
import type Autocomplete from './autocomplete.vue';
import type { Placement } from 'element-plus/es/components/popper';
import type { Awaitable } from 'element-plus/es/utils';
export declare type AutocompleteData = Record<string, any>[];
export declare type AutocompleteFetchSuggestionsCallback = (data: AutocompleteData) => void;
export declare type AutocompleteFetchSuggestions = ((queryString: string, cb: AutocompleteFetchSuggestionsCallback) => Awaitable<AutocompleteData> | void) | AutocompleteData;
export declare const autocompleteProps: {
    readonly ariaLabel: StringConstructor;
    readonly valueKey: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
    readonly debounce: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
    readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Placement & {}) | (() => Placement) | ((new (...args: any[]) => Placement & {}) | (() => Placement))[], "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end", unknown, "bottom-start", boolean>;
    readonly fetchSuggestions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => AutocompleteData | ((queryString: string, cb: AutocompleteFetchSuggestionsCallback) => Awaitable<AutocompleteData> | void)) | (() => AutocompleteFetchSuggestions) | ((new (...args: any[]) => AutocompleteData | ((queryString: string, cb: AutocompleteFetchSuggestionsCallback) => Awaitable<AutocompleteData> | void)) | (() => AutocompleteFetchSuggestions))[], unknown, unknown, () => void, boolean>;
    readonly popperClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly triggerOnFocus: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly selectWhenUnmatched: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly hideLoading: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly highlightFirstItem: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly fitInputWidth: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly name: StringConstructor;
};
export declare type AutocompleteProps = ExtractPropTypes<typeof autocompleteProps>;
export declare const autocompleteEmits: {
    "update:modelValue": (value: string) => boolean;
    input: (value: string) => boolean;
    change: (value: string) => boolean;
    focus: (evt: FocusEvent) => boolean;
    blur: (evt: FocusEvent) => boolean;
    clear: () => boolean;
    select: (item: Record<string, any>) => boolean;
};
export declare type AutocompleteEmits = typeof autocompleteEmits;
export declare type AutocompleteInstance = InstanceType<typeof Autocomplete>;


code:
'use strict';

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

require('../../../utils/index.js');
require('../../tooltip/index.js');
require('../../../hooks/index.js');
require('../../../constants/index.js');
var runtime = require('../../../utils/vue/props/runtime.js');
var shared = require('@vue/shared');
var content = require('../../tooltip/src/content.js');
var index = require('../../../hooks/use-aria/index.js');
var event = require('../../../constants/event.js');

const autocompleteProps = runtime.buildProps({
  valueKey: {
    type: String,
    default: "value"
  },
  modelValue: {
    type: [String, Number],
    default: ""
  },
  debounce: {
    type: Number,
    default: 300
  },
  placement: {
    type: runtime.definePropType(String),
    values: [
      "top",
      "top-start",
      "top-end",
      "bottom",
      "bottom-start",
      "bottom-end"
    ],
    default: "bottom-start"
  },
  fetchSuggestions: {
    type: runtime.definePropType([Function, Array]),
    default: shared.NOOP
  },
  popperClass: {
    type: String,
    default: ""
  },
  triggerOnFocus: {
    type: Boolean,
    default: true
  },
  selectWhenUnmatched: {
    type: Boolean,
    default: false
  },
  hideLoading: {
    type: Boolean,
    default: false
  },
  teleported: content.useTooltipContentProps.teleported,
  highlightFirstItem: {
    type: Boolean,
    default: false
  },
  fitInputWidth: {
    type: Boolean,
    default: false
  },
  clearable: {
    type: Boolean,
    default: false
  },
  disabled: {
    type: Boolean,
    default: false
  },
  name: String,
  ...index.useAriaProps(["ariaLabel"])
});
const autocompleteEmits = {
  [event.UPDATE_MODEL_EVENT]: (value) => shared.isString(value),
  [event.INPUT_EVENT]: (value) => shared.isString(value),
  [event.CHANGE_EVENT]: (value) => shared.isString(value),
  focus: (evt) => evt instanceof FocusEvent,
  blur: (evt) => evt instanceof FocusEvent,
  clear: () => true,
  select: (item) => shared.isObject(item)
};

exports.autocompleteEmits = autocompleteEmits;
exports.autocompleteProps = autocompleteProps;
//# sourceMappingURL=autocomplete.js.map