init

node_modules/element-plus/lib/components/collapse/index.d.ts

@@ -0,0 +1,12 @@
+import Collapse from './src/collapse.vue';
+import CollapseItem from './src/collapse-item.vue';
+import type { SFCWithInstall } from 'element-plus/es/utils';
+export declare const ElCollapse: SFCWithInstall<typeof Collapse> & {
+    CollapseItem: typeof CollapseItem;
+};
+export default ElCollapse;
+export declare const ElCollapseItem: SFCWithInstall<typeof CollapseItem>;
+export * from './src/collapse';
+export * from './src/collapse-item';
+export * from './src/constants';
+export type { CollapseInstance, CollapseItemInstance } from './src/instance';

node_modules/element-plus/lib/components/collapse/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var collapse$1 = require('./src/collapse2.js');
+var collapseItem$1 = require('./src/collapse-item2.js');
+var collapse = require('./src/collapse.js');
+var collapseItem = require('./src/collapse-item.js');
+var constants = require('./src/constants.js');
+var install = require('../../utils/vue/install.js');
+
+const ElCollapse = install.withInstall(collapse$1["default"], {
+  CollapseItem: collapseItem$1["default"]
+});
+const ElCollapseItem = install.withNoopInstall(collapseItem$1["default"]);
+
+exports.collapseEmits = collapse.collapseEmits;
+exports.collapseProps = collapse.collapseProps;
+exports.emitChangeFn = collapse.emitChangeFn;
+exports.collapseItemProps = collapseItem.collapseItemProps;
+exports.collapseContextKey = constants.collapseContextKey;
+exports.ElCollapse = ElCollapse;
+exports.ElCollapseItem = ElCollapseItem;
+exports["default"] = ElCollapse;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/collapse/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../packages/components/collapse/index.ts"],"sourcesContent":["import { withInstall, withNoopInstall } from '@element-plus/utils'\nimport Collapse from './src/collapse.vue'\nimport CollapseItem from './src/collapse-item.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElCollapse: SFCWithInstall<typeof Collapse> & {\n  CollapseItem: typeof CollapseItem\n} = withInstall(Collapse, {\n  CollapseItem,\n})\nexport default ElCollapse\nexport const ElCollapseItem: SFCWithInstall<typeof CollapseItem> =\n  withNoopInstall(CollapseItem)\n\nexport * from './src/collapse'\nexport * from './src/collapse-item'\nexport * from './src/constants'\nexport type { CollapseInstance, CollapseItemInstance } from './src/instance'\n"],"names":["withInstall","Collapse","CollapseItem","withNoopInstall"],"mappings":";;;;;;;;;;;AAGY,MAAC,UAAU,GAAGA,mBAAW,CAACC,qBAAQ,EAAE;AAChD,gBAAEC,yBAAY;AACd,CAAC,EAAE;AAES,MAAC,cAAc,GAAGC,uBAAe,CAACD,yBAAY;;;;;;;;;;;"}

node_modules/element-plus/lib/components/collapse/src/collapse-item.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { CollapseActiveName } from './collapse';
+export declare const collapseItemProps: {
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly name: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => CollapseActiveName) | ((new (...args: any[]) => string | number) | (() => CollapseActiveName))[], unknown, unknown, undefined, boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+};
+export type CollapseItemProps = ExtractPropTypes<typeof collapseItemProps>;
+export type CollapseItemPropsPublic = __ExtractPublicPropTypes<typeof collapseItemProps>;

node_modules/element-plus/lib/components/collapse/src/collapse-item.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var iconsVue = require('@element-plus/icons-vue');
+var runtime = require('../../../utils/vue/props/runtime.js');
+var icon = require('../../../utils/vue/icon.js');
+
+const collapseItemProps = runtime.buildProps({
+  title: {
+    type: String,
+    default: ""
+  },
+  name: {
+    type: runtime.definePropType([String, Number]),
+    default: void 0
+  },
+  icon: {
+    type: icon.iconPropType,
+    default: iconsVue.ArrowRight
+  },
+  disabled: Boolean
+});
+
+exports.collapseItemProps = collapseItemProps;
+//# sourceMappingURL=collapse-item.js.map

node_modules/element-plus/lib/components/collapse/src/collapse-item.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse-item.js","sources":["../../../../../../packages/components/collapse/src/collapse-item.ts"],"sourcesContent":["import { buildProps, definePropType, iconPropType } from '@element-plus/utils'\nimport { ArrowRight } from '@element-plus/icons-vue'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { CollapseActiveName } from './collapse'\n\nexport const collapseItemProps = buildProps({\n  /**\n   * @description title of the panel\n   */\n  title: {\n    type: String,\n    default: '',\n  },\n  /**\n   * @description unique identification of the panel\n   */\n  name: {\n    type: definePropType<CollapseActiveName>([String, Number]),\n    default: undefined,\n  },\n  /**\n   * @description icon of the collapse item\n   */\n  icon: {\n    type: iconPropType,\n    default: ArrowRight,\n  },\n  /**\n   * @description disable the collapse item\n   */\n  disabled: Boolean,\n} as const)\nexport type CollapseItemProps = ExtractPropTypes<typeof collapseItemProps>\nexport type CollapseItemPropsPublic = __ExtractPublicPropTypes<\n  typeof collapseItemProps\n>\n"],"names":["buildProps","definePropType","iconPropType","ArrowRight"],"mappings":";;;;;;;;AAEY,MAAC,iBAAiB,GAAGA,kBAAU,CAAC;AAC5C,EAAE,KAAK,EAAE;AACT,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAEC,sBAAc,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC1C,IAAI,OAAO,EAAE,KAAK,CAAC;AACnB,GAAG;AACH,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAEC,iBAAY;AACtB,IAAI,OAAO,EAAEC,mBAAU;AACvB,GAAG;AACH,EAAE,QAAQ,EAAE,OAAO;AACnB,CAAC;;;;"}

node_modules/element-plus/lib/components/collapse/src/collapse-item.vue.d.ts

@@ -0,0 +1,44 @@
+declare function __VLS_template(): {
+    title?(_: {
+        isActive: boolean | undefined;
+    }): any;
+    icon?(_: {
+        isActive: boolean | undefined;
+    }): any;
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly name: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => import("element-plus").CollapseActiveName) | ((new (...args: any[]) => string | number) | (() => import("element-plus").CollapseActiveName))[], unknown, unknown, undefined, boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+}, {
+    /** @description current collapse-item whether active */
+    isActive: import("vue").ComputedRef<boolean | undefined>;
+}, 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 title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly name: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => import("element-plus").CollapseActiveName) | ((new (...args: any[]) => string | number) | (() => import("element-plus").CollapseActiveName))[], unknown, unknown, undefined, boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | ((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabled: BooleanConstructor;
+}>>, {
+    readonly title: string;
+    readonly disabled: boolean;
+    readonly name: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => import("element-plus").CollapseActiveName) | ((new (...args: any[]) => string | number) | (() => import("element-plus").CollapseActiveName))[], unknown, unknown>;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/element-plus/lib/components/collapse/src/collapse-item2.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index$1 = require('../../collapse-transition/index.js');
+var index = require('../../icon/index.js');
+var collapseItem = require('./collapse-item.js');
+var useCollapseItem = require('./use-collapse-item.js');
+var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({
+  name: "ElCollapseItem"
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: collapseItem.collapseItemProps,
+  setup(__props, { expose }) {
+    const props = __props;
+    const {
+      focusing,
+      id,
+      isActive,
+      handleFocus,
+      handleHeaderClick,
+      handleEnterClick
+    } = useCollapseItem.useCollapseItem(props);
+    const {
+      arrowKls,
+      headKls,
+      rootKls,
+      itemTitleKls,
+      itemWrapperKls,
+      itemContentKls,
+      scopedContentId,
+      scopedHeadId
+    } = useCollapseItem.useCollapseItemDOM(props, { focusing, isActive, id });
+    expose({
+      isActive
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(rootKls))
+      }, [
+        vue.createElementVNode("div", {
+          id: vue.unref(scopedHeadId),
+          class: vue.normalizeClass(vue.unref(headKls)),
+          "aria-expanded": vue.unref(isActive),
+          "aria-controls": vue.unref(scopedContentId),
+          "aria-describedby": vue.unref(scopedContentId),
+          tabindex: _ctx.disabled ? -1 : 0,
+          role: "button",
+          onClick: vue.unref(handleHeaderClick),
+          onKeydown: vue.withKeys(vue.withModifiers(vue.unref(handleEnterClick), ["stop"]), ["space", "enter"]),
+          onFocus: vue.unref(handleFocus),
+          onBlur: ($event) => focusing.value = false
+        }, [
+          vue.createElementVNode("span", {
+            class: vue.normalizeClass(vue.unref(itemTitleKls))
+          }, [
+            vue.renderSlot(_ctx.$slots, "title", { isActive: vue.unref(isActive) }, () => [
+              vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
+            ])
+          ], 2),
+          vue.renderSlot(_ctx.$slots, "icon", { isActive: vue.unref(isActive) }, () => [
+            vue.createVNode(vue.unref(index.ElIcon), {
+              class: vue.normalizeClass(vue.unref(arrowKls))
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
+              ]),
+              _: 1
+            }, 8, ["class"])
+          ])
+        ], 42, ["id", "aria-expanded", "aria-controls", "aria-describedby", "tabindex", "onClick", "onKeydown", "onFocus", "onBlur"]),
+        vue.createVNode(vue.unref(index$1.ElCollapseTransition), null, {
+          default: vue.withCtx(() => [
+            vue.withDirectives(vue.createElementVNode("div", {
+              id: vue.unref(scopedContentId),
+              role: "region",
+              class: vue.normalizeClass(vue.unref(itemWrapperKls)),
+              "aria-hidden": !vue.unref(isActive),
+              "aria-labelledby": vue.unref(scopedHeadId)
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(itemContentKls))
+              }, [
+                vue.renderSlot(_ctx.$slots, "default")
+              ], 2)
+            ], 10, ["id", "aria-hidden", "aria-labelledby"]), [
+              [vue.vShow, vue.unref(isActive)]
+            ])
+          ]),
+          _: 3
+        })
+      ], 2);
+    };
+  }
+});
+var CollapseItem = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "collapse-item.vue"]]);
+
+exports["default"] = CollapseItem;
+//# sourceMappingURL=collapse-item2.js.map

node_modules/element-plus/lib/components/collapse/src/collapse-item2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse-item2.js","sources":["../../../../../../packages/components/collapse/src/collapse-item.vue"],"sourcesContent":["<template>\n  <div :class=\"rootKls\">\n    <div\n      :id=\"scopedHeadId\"\n      :class=\"headKls\"\n      :aria-expanded=\"isActive\"\n      :aria-controls=\"scopedContentId\"\n      :aria-describedby=\"scopedContentId\"\n      :tabindex=\"disabled ? -1 : 0\"\n      role=\"button\"\n      @click=\"handleHeaderClick\"\n      @keydown.space.enter.stop=\"handleEnterClick\"\n      @focus=\"handleFocus\"\n      @blur=\"focusing = false\"\n    >\n      <span :class=\"itemTitleKls\">\n        <slot name=\"title\" :is-active=\"isActive\">{{ title }}</slot>\n      </span>\n      <slot name=\"icon\" :is-active=\"isActive\">\n        <el-icon :class=\"arrowKls\">\n          <component :is=\"icon\" />\n        </el-icon>\n      </slot>\n    </div>\n\n    <el-collapse-transition>\n      <div\n        v-show=\"isActive\"\n        :id=\"scopedContentId\"\n        role=\"region\"\n        :class=\"itemWrapperKls\"\n        :aria-hidden=\"!isActive\"\n        :aria-labelledby=\"scopedHeadId\"\n      >\n        <div :class=\"itemContentKls\">\n          <slot />\n        </div>\n      </div>\n    </el-collapse-transition>\n  </div>\n</template>\n\n<script lang=\"ts\" setup>\nimport ElCollapseTransition from '@element-plus/components/collapse-transition'\nimport ElIcon from '@element-plus/components/icon'\nimport { collapseItemProps } from './collapse-item'\nimport { useCollapseItem, useCollapseItemDOM } from './use-collapse-item'\n\ndefineOptions({\n  name: 'ElCollapseItem',\n})\n\nconst props = defineProps(collapseItemProps)\nconst {\n  focusing,\n  id,\n  isActive,\n  handleFocus,\n  handleHeaderClick,\n  handleEnterClick,\n} = useCollapseItem(props)\n\nconst {\n  arrowKls,\n  headKls,\n  rootKls,\n  itemTitleKls,\n  itemWrapperKls,\n  itemContentKls,\n  scopedContentId,\n  scopedHeadId,\n} = useCollapseItemDOM(props, { focusing, isActive, id })\n\ndefineExpose({\n  /** @description current collapse-item whether active */\n  isActive,\n})\n</script>\n"],"names":["useCollapseItem","useCollapseItemDOM"],"mappings":";;;;;;;;;;;uCAgDc,CAAA;AAAA,EACZ,IAAM,EAAA,gBAAA;AACR,CAAA,CAAA,CAAA;;;;;;AAGA,IAAM,MAAA;AAAA,MACJ,QAAA;AAAA,MACA,EAAA;AAAA,MACA,QAAA;AAAA,MACA,WAAA;AAAA,MACA,iBAAA;AAAA,MACA,gBAAA;AAAA,KACF,GAAIA,gCAAgB,KAAK,CAAA,CAAA;AAEzB,IAAM,MAAA;AAAA,MACJ,QAAA;AAAA,MACA,OAAA;AAAA,MACA,OAAA;AAAA,MACA,YAAA;AAAA,MACA,cAAA;AAAA,MACA,cAAA;AAAA,MACA,eAAA;AAAA,MACA,YAAA;AAAA,QACEC,kCAAmB,CAAA,KAAA,EAAO,EAAE,QAAU,EAAA,QAAA,EAAU,IAAI,CAAA,CAAA;AAExD,IAAa,MAAA,CAAA;AAAA,MAAA,QAAA;AAAA,KAEX,CAAA,CAAA;AAAA,IACF,OAAC,CAAA,IAAA,EAAA,MAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/element-plus/lib/components/collapse/src/collapse.d.ts

@@ -0,0 +1,24 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { Arrayable, Awaitable } from 'element-plus/es/utils';
+export type CollapseActiveName = string | number;
+export type CollapseModelValue = Arrayable<CollapseActiveName>;
+export type CollapseIconPositionType = 'left' | 'right';
+export declare const emitChangeFn: (value: CollapseModelValue) => value is string | number | CollapseActiveName[];
+export declare const collapseProps: {
+    readonly accordion: BooleanConstructor;
+    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | CollapseActiveName[]) | (() => CollapseModelValue) | ((new (...args: any[]) => string | number | CollapseActiveName[]) | (() => CollapseModelValue))[], unknown, unknown, () => [], boolean>;
+    readonly expandIconPosition: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right") | (() => CollapseIconPositionType) | ((new (...args: any[]) => "left" | "right") | (() => CollapseIconPositionType))[], unknown, unknown, "right", boolean>;
+    readonly beforeCollapse: {
+        readonly type: import("vue").PropType<(name: CollapseActiveName) => Awaitable<boolean>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type CollapseProps = ExtractPropTypes<typeof collapseProps>;
+export type CollapsePropsPublic = __ExtractPublicPropTypes<typeof collapseProps>;
+export declare const collapseEmits: {
+    "update:modelValue": (value: CollapseModelValue) => value is string | number | CollapseActiveName[];
+    change: (value: CollapseModelValue) => value is string | number | CollapseActiveName[];
+};
+export type CollapseEmits = typeof collapseEmits;

node_modules/element-plus/lib/components/collapse/src/collapse.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../utils/vue/props/runtime.js');
+var typescript = require('../../../utils/typescript.js');
+var types = require('../../../utils/types.js');
+var shared = require('@vue/shared');
+var event = require('../../../constants/event.js');
+
+const emitChangeFn = (value) => types.isNumber(value) || shared.isString(value) || shared.isArray(value);
+const collapseProps = runtime.buildProps({
+  accordion: Boolean,
+  modelValue: {
+    type: runtime.definePropType([Array, String, Number]),
+    default: () => typescript.mutable([])
+  },
+  expandIconPosition: {
+    type: runtime.definePropType([String]),
+    default: "right"
+  },
+  beforeCollapse: {
+    type: runtime.definePropType(Function)
+  }
+});
+const collapseEmits = {
+  [event.UPDATE_MODEL_EVENT]: emitChangeFn,
+  [event.CHANGE_EVENT]: emitChangeFn
+};
+
+exports.collapseEmits = collapseEmits;
+exports.collapseProps = collapseProps;
+exports.emitChangeFn = emitChangeFn;
+//# sourceMappingURL=collapse.js.map

node_modules/element-plus/lib/components/collapse/src/collapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse.js","sources":["../../../../../../packages/components/collapse/src/collapse.ts"],"sourcesContent":["import {\n  buildProps,\n  definePropType,\n  isArray,\n  isNumber,\n  isString,\n  mutable,\n} from '@element-plus/utils'\nimport { CHANGE_EVENT, UPDATE_MODEL_EVENT } from '@element-plus/constants'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { Arrayable, Awaitable } from '@element-plus/utils'\n\nexport type CollapseActiveName = string | number\nexport type CollapseModelValue = Arrayable<CollapseActiveName>\n\nexport type CollapseIconPositionType = 'left' | 'right'\n\nexport const emitChangeFn = (value: CollapseModelValue) =>\n  isNumber(value) || isString(value) || isArray(value)\n\nexport const collapseProps = buildProps({\n  /**\n   * @description whether to activate accordion mode\n   */\n  accordion: Boolean,\n  /**\n   * @description currently active panel, the type is `string` in accordion mode, otherwise it is `array`\n   */\n  modelValue: {\n    type: definePropType<CollapseModelValue>([Array, String, Number]),\n    default: () => mutable([] as const),\n  },\n  /**\n   * @description set expand icon position\n   */\n  expandIconPosition: {\n    type: definePropType<CollapseIconPositionType>([String]),\n    default: 'right',\n  },\n  /**\n   * @description before-collapse hook before the collapse state changes. If `false` is returned or a `Promise` is returned and then is rejected, will stop collapsing\n   */\n  beforeCollapse: {\n    type: definePropType<(name: CollapseActiveName) => Awaitable<boolean>>(\n      Function\n    ),\n  },\n} as const)\nexport type CollapseProps = ExtractPropTypes<typeof collapseProps>\nexport type CollapsePropsPublic = __ExtractPublicPropTypes<typeof collapseProps>\n\nexport const collapseEmits = {\n  [UPDATE_MODEL_EVENT]: emitChangeFn,\n  [CHANGE_EVENT]: emitChangeFn,\n}\nexport type CollapseEmits = typeof collapseEmits\n"],"names":["isNumber","isString","isArray","buildProps","definePropType","mutable","UPDATE_MODEL_EVENT","CHANGE_EVENT"],"mappings":";;;;;;;;;;AASY,MAAC,YAAY,GAAG,CAAC,KAAK,KAAKA,cAAQ,CAAC,KAAK,CAAC,IAAIC,eAAQ,CAAC,KAAK,CAAC,IAAIC,cAAO,CAAC,KAAK,EAAE;AAChF,MAAC,aAAa,GAAGC,kBAAU,CAAC;AACxC,EAAE,SAAS,EAAE,OAAO;AACpB,EAAE,UAAU,EAAE;AACd,IAAI,IAAI,EAAEC,sBAAc,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACjD,IAAI,OAAO,EAAE,MAAMC,kBAAO,CAAC,EAAE,CAAC;AAC9B,GAAG;AACH,EAAE,kBAAkB,EAAE;AACtB,IAAI,IAAI,EAAED,sBAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAClC,IAAI,OAAO,EAAE,OAAO;AACpB,GAAG;AACH,EAAE,cAAc,EAAE;AAClB,IAAI,IAAI,EAAEA,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,CAAC,EAAE;AACS,MAAC,aAAa,GAAG;AAC7B,EAAE,CAACE,wBAAkB,GAAG,YAAY;AACpC,EAAE,CAACC,kBAAY,GAAG,YAAY;AAC9B;;;;;;"}

node_modules/element-plus/lib/components/collapse/src/collapse.vue.d.ts

@@ -0,0 +1,46 @@
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly accordion: BooleanConstructor;
+    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | import("./collapse").CollapseActiveName[]) | (() => import("./collapse").CollapseModelValue) | ((new (...args: any[]) => string | number | import("./collapse").CollapseActiveName[]) | (() => import("./collapse").CollapseModelValue))[], unknown, unknown, () => [], boolean>;
+    readonly expandIconPosition: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right") | (() => import("./collapse").CollapseIconPositionType) | ((new (...args: any[]) => "left" | "right") | (() => import("./collapse").CollapseIconPositionType))[], unknown, unknown, "right", boolean>;
+    readonly beforeCollapse: {
+        readonly type: import("vue").PropType<(name: import("./collapse").CollapseActiveName) => import("element-plus/es/utils").Awaitable<boolean>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    /** @description active names */
+    activeNames: import("vue").Ref<(string | number)[]>;
+    /** @description set active names */
+    setActiveNames: (_activeNames: import("./collapse").CollapseActiveName[]) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("./collapse").CollapseModelValue) => void;
+    change: (value: import("./collapse").CollapseModelValue) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly accordion: BooleanConstructor;
+    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | import("./collapse").CollapseActiveName[]) | (() => import("./collapse").CollapseModelValue) | ((new (...args: any[]) => string | number | import("./collapse").CollapseActiveName[]) | (() => import("./collapse").CollapseModelValue))[], unknown, unknown, () => [], boolean>;
+    readonly expandIconPosition: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right") | (() => import("./collapse").CollapseIconPositionType) | ((new (...args: any[]) => "left" | "right") | (() => import("./collapse").CollapseIconPositionType))[], unknown, unknown, "right", boolean>;
+    readonly beforeCollapse: {
+        readonly type: import("vue").PropType<(name: import("./collapse").CollapseActiveName) => import("element-plus/es/utils").Awaitable<boolean>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((value: import("./collapse").CollapseModelValue) => any) | undefined;
+    onChange?: ((value: import("./collapse").CollapseModelValue) => any) | undefined;
+}, {
+    readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number | import("./collapse").CollapseActiveName[]) | (() => import("./collapse").CollapseModelValue) | ((new (...args: any[]) => string | number | import("./collapse").CollapseActiveName[]) | (() => import("./collapse").CollapseModelValue))[], unknown, unknown>;
+    readonly expandIconPosition: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "left" | "right") | (() => import("./collapse").CollapseIconPositionType) | ((new (...args: any[]) => "left" | "right") | (() => import("./collapse").CollapseIconPositionType))[], unknown, unknown>;
+    readonly accordion: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/element-plus/lib/components/collapse/src/collapse2.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var collapse = require('./collapse.js');
+var useCollapse = require('./use-collapse.js');
+var pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({
+  name: "ElCollapse"
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: collapse.collapseProps,
+  emits: collapse.collapseEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { activeNames, setActiveNames } = useCollapse.useCollapse(props, emit);
+    const { rootKls } = useCollapse.useCollapseDOM(props);
+    expose({
+      activeNames,
+      setActiveNames
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(rootKls))
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+var Collapse = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "collapse.vue"]]);
+
+exports["default"] = Collapse;
+//# sourceMappingURL=collapse2.js.map

node_modules/element-plus/lib/components/collapse/src/collapse2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse2.js","sources":["../../../../../../packages/components/collapse/src/collapse.vue"],"sourcesContent":["<template>\n  <div :class=\"rootKls\">\n    <slot />\n  </div>\n</template>\n\n<script lang=\"ts\" setup>\nimport { collapseEmits, collapseProps } from './collapse'\nimport { useCollapse, useCollapseDOM } from './use-collapse'\n\ndefineOptions({\n  name: 'ElCollapse',\n})\nconst props = defineProps(collapseProps)\nconst emit = defineEmits(collapseEmits)\n\nconst { activeNames, setActiveNames } = useCollapse(props, emit)\n\nconst { rootKls } = useCollapseDOM(props)\n\ndefineExpose({\n  /** @description active names */\n  activeNames,\n  /** @description set active names */\n  setActiveNames,\n})\n</script>\n"],"names":["useCollapse","useCollapseDOM","_openBlock","_createElementBlock"],"mappings":";;;;;;;;;uCAUc,CAAA;AAAA,EACZ,IAAM,EAAA,YAAA;AACR,CAAA,CAAA,CAAA;;;;;;;AAIA,IAAA,MAAM,EAAE,WAAa,EAAA,cAAA,EAAmB,GAAAA,uBAAA,CAAY,OAAO,IAAI,CAAA,CAAA;AAE/D,IAAA,MAAM,EAAE,OAAA,EAAY,GAAAC,0BAAA,CAAe,KAAK,CAAA,CAAA;AAExC,IAAa,MAAA,CAAA;AAAA,MAAA,WAAA;AAAA,MAEX,cAAA;AAAA,KAAA,CAAA,CAAA;AAAA,IAEA,OAAA,CAAA,IAAA,EAAA,MAAA,KAAA;AAAA,MACD,OAAAC,aAAA,EAAA,EAAAC,sBAAA,CAAA,KAAA,EAAA;;;;;;;;;;;;"}

node_modules/element-plus/lib/components/collapse/src/constants.d.ts

@@ -0,0 +1,7 @@
+import type { InjectionKey, Ref } from 'vue';
+import type { CollapseActiveName } from './collapse';
+export interface CollapseContext {
+    activeNames: Ref<CollapseActiveName[]>;
+    handleItemClick: (name: CollapseActiveName) => void;
+}
+export declare const collapseContextKey: InjectionKey<CollapseContext>;

node_modules/element-plus/lib/components/collapse/src/constants.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const collapseContextKey = Symbol("collapseContextKey");
+
+exports.collapseContextKey = collapseContextKey;
+//# sourceMappingURL=constants.js.map

node_modules/element-plus/lib/components/collapse/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../../packages/components/collapse/src/constants.ts"],"sourcesContent":["import type { InjectionKey, Ref } from 'vue'\nimport type { CollapseActiveName } from './collapse'\n\nexport interface CollapseContext {\n  activeNames: Ref<CollapseActiveName[]>\n  handleItemClick: (name: CollapseActiveName) => void\n}\n\nexport const collapseContextKey: InjectionKey<CollapseContext> =\n  Symbol('collapseContextKey')\n"],"names":[],"mappings":";;;;AAAY,MAAC,kBAAkB,GAAG,MAAM,CAAC,oBAAoB;;;;"}

node_modules/element-plus/lib/components/collapse/src/instance.d.ts

@@ -0,0 +1,4 @@
+import type Collapse from './collapse.vue';
+import type CollapseItem from './collapse-item.vue';
+export type CollapseInstance = InstanceType<typeof Collapse> & unknown;
+export type CollapseItemInstance = InstanceType<typeof CollapseItem> & unknown;

node_modules/element-plus/lib/components/collapse/src/instance.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=instance.js.map

node_modules/element-plus/lib/components/collapse/src/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

node_modules/element-plus/lib/components/collapse/src/use-collapse-item.d.ts

@@ -0,0 +1,21 @@
+import type { CollapseItemProps } from './collapse-item';
+export declare const useCollapseItem: (props: CollapseItemProps) => {
+    focusing: import("vue").Ref<boolean>;
+    id: import("vue").ComputedRef<number>;
+    isActive: import("vue").ComputedRef<boolean | undefined>;
+    handleFocus: () => void;
+    handleHeaderClick: (e: MouseEvent) => void;
+    handleEnterClick: (e: KeyboardEvent) => void;
+};
+export declare const useCollapseItemDOM: (props: CollapseItemProps, { focusing, isActive, id }: Partial<ReturnType<typeof useCollapseItem>>) => {
+    itemTitleKls: import("vue").ComputedRef<string[]>;
+    arrowKls: import("vue").ComputedRef<string[]>;
+    headKls: import("vue").ComputedRef<(string | {
+        focusing: boolean | undefined;
+    })[]>;
+    rootKls: import("vue").ComputedRef<string[]>;
+    itemWrapperKls: import("vue").ComputedRef<string>;
+    itemContentKls: import("vue").ComputedRef<string>;
+    scopedContentId: import("vue").ComputedRef<string>;
+    scopedHeadId: import("vue").ComputedRef<string>;
+};

node_modules/element-plus/lib/components/collapse/src/use-collapse-item.js

@@ -0,0 +1,92 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var constants = require('./constants.js');
+var index$1 = require('../../../hooks/use-id/index.js');
+var index = require('../../../hooks/use-namespace/index.js');
+
+const useCollapseItem = (props) => {
+  const collapse = vue.inject(constants.collapseContextKey);
+  const { namespace } = index.useNamespace("collapse");
+  const focusing = vue.ref(false);
+  const isClick = vue.ref(false);
+  const idInjection = index$1.useIdInjection();
+  const id = vue.computed(() => idInjection.current++);
+  const name = vue.computed(() => {
+    var _a;
+    return (_a = props.name) != null ? _a : `${namespace.value}-id-${idInjection.prefix}-${vue.unref(id)}`;
+  });
+  const isActive = vue.computed(() => collapse == null ? void 0 : collapse.activeNames.value.includes(vue.unref(name)));
+  const handleFocus = () => {
+    setTimeout(() => {
+      if (!isClick.value) {
+        focusing.value = true;
+      } else {
+        isClick.value = false;
+      }
+    }, 50);
+  };
+  const handleHeaderClick = (e) => {
+    if (props.disabled)
+      return;
+    const target = e.target;
+    if (target == null ? void 0 : target.closest("input, textarea, select"))
+      return;
+    collapse == null ? void 0 : collapse.handleItemClick(vue.unref(name));
+    focusing.value = false;
+    isClick.value = true;
+  };
+  const handleEnterClick = (e) => {
+    const target = e.target;
+    if (target == null ? void 0 : target.closest("input, textarea, select"))
+      return;
+    e.preventDefault();
+    collapse == null ? void 0 : collapse.handleItemClick(vue.unref(name));
+  };
+  return {
+    focusing,
+    id,
+    isActive,
+    handleFocus,
+    handleHeaderClick,
+    handleEnterClick
+  };
+};
+const useCollapseItemDOM = (props, { focusing, isActive, id }) => {
+  const ns = index.useNamespace("collapse");
+  const rootKls = vue.computed(() => [
+    ns.b("item"),
+    ns.is("active", vue.unref(isActive)),
+    ns.is("disabled", props.disabled)
+  ]);
+  const headKls = vue.computed(() => [
+    ns.be("item", "header"),
+    ns.is("active", vue.unref(isActive)),
+    { focusing: vue.unref(focusing) && !props.disabled }
+  ]);
+  const arrowKls = vue.computed(() => [
+    ns.be("item", "arrow"),
+    ns.is("active", vue.unref(isActive))
+  ]);
+  const itemTitleKls = vue.computed(() => [ns.be("item", "title")]);
+  const itemWrapperKls = vue.computed(() => ns.be("item", "wrap"));
+  const itemContentKls = vue.computed(() => ns.be("item", "content"));
+  const scopedContentId = vue.computed(() => ns.b(`content-${vue.unref(id)}`));
+  const scopedHeadId = vue.computed(() => ns.b(`head-${vue.unref(id)}`));
+  return {
+    itemTitleKls,
+    arrowKls,
+    headKls,
+    rootKls,
+    itemWrapperKls,
+    itemContentKls,
+    scopedContentId,
+    scopedHeadId
+  };
+};
+
+exports.useCollapseItem = useCollapseItem;
+exports.useCollapseItemDOM = useCollapseItemDOM;
+//# sourceMappingURL=use-collapse-item.js.map

node_modules/element-plus/lib/components/collapse/src/use-collapse.d.ts

@@ -0,0 +1,9 @@
+import type { SetupContext } from 'vue';
+import type { CollapseActiveName, CollapseEmits, CollapseProps } from './collapse';
+export declare const useCollapse: (props: CollapseProps, emit: SetupContext<CollapseEmits>["emit"]) => {
+    activeNames: import("vue").Ref<(string | number)[]>;
+    setActiveNames: (_activeNames: CollapseActiveName[]) => void;
+};
+export declare const useCollapseDOM: (props: CollapseProps) => {
+    rootKls: import("vue").ComputedRef<string[]>;
+};

node_modules/element-plus/lib/components/collapse/src/use-collapse.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var constants = require('./constants.js');
+var lodashUnified = require('lodash-unified');
+var event = require('../../../constants/event.js');
+var index = require('../../../hooks/use-namespace/index.js');
+var shared = require('@vue/shared');
+var types = require('../../../utils/types.js');
+var error = require('../../../utils/error.js');
+
+const SCOPE = "ElCollapse";
+const useCollapse = (props, emit) => {
+  const activeNames = vue.ref(lodashUnified.castArray(props.modelValue));
+  const setActiveNames = (_activeNames) => {
+    activeNames.value = _activeNames;
+    const value = props.accordion ? activeNames.value[0] : activeNames.value;
+    emit(event.UPDATE_MODEL_EVENT, value);
+    emit(event.CHANGE_EVENT, value);
+  };
+  const handleChange = (name) => {
+    if (props.accordion) {
+      setActiveNames([activeNames.value[0] === name ? "" : name]);
+    } else {
+      const _activeNames = [...activeNames.value];
+      const index = _activeNames.indexOf(name);
+      if (index > -1) {
+        _activeNames.splice(index, 1);
+      } else {
+        _activeNames.push(name);
+      }
+      setActiveNames(_activeNames);
+    }
+  };
+  const handleItemClick = async (name) => {
+    const { beforeCollapse } = props;
+    if (!beforeCollapse) {
+      handleChange(name);
+      return;
+    }
+    const shouldChange = beforeCollapse(name);
+    const isPromiseOrBool = [
+      shared.isPromise(shouldChange),
+      types.isBoolean(shouldChange)
+    ].includes(true);
+    if (!isPromiseOrBool) {
+      error.throwError(SCOPE, "beforeCollapse must return type `Promise<boolean>` or `boolean`");
+    }
+    if (shared.isPromise(shouldChange)) {
+      shouldChange.then((result) => {
+        if (result !== false) {
+          handleChange(name);
+        }
+      }).catch((e) => {
+      });
+    } else if (shouldChange) {
+      handleChange(name);
+    }
+  };
+  vue.watch(() => props.modelValue, () => activeNames.value = lodashUnified.castArray(props.modelValue), { deep: true });
+  vue.provide(constants.collapseContextKey, {
+    activeNames,
+    handleItemClick
+  });
+  return {
+    activeNames,
+    setActiveNames
+  };
+};
+const useCollapseDOM = (props) => {
+  const ns = index.useNamespace("collapse");
+  const rootKls = vue.computed(() => [
+    ns.b(),
+    ns.b(`icon-position-${props.expandIconPosition}`)
+  ]);
+  return {
+    rootKls
+  };
+};
+
+exports.useCollapse = useCollapse;
+exports.useCollapseDOM = useCollapseDOM;
+//# sourceMappingURL=use-collapse.js.map

node_modules/element-plus/lib/components/collapse/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-collapse.css';

node_modules/element-plus/lib/components/collapse/style/css.js

@@ -0,0 +1,6 @@
+'use strict';
+
+require('../../base/style/css.js');
+require('element-plus/theme-chalk/el-collapse.css');
+
+//# sourceMappingURL=css.js.map

node_modules/element-plus/lib/components/collapse/style/css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

node_modules/element-plus/lib/components/collapse/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/collapse.scss';

node_modules/element-plus/lib/components/collapse/style/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+require('../../base/style/index.js');
+require('element-plus/theme-chalk/src/collapse.scss');
+
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/collapse/style/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}