@funcho/ui 1.0.0

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/tree/src/tree2.js

@@ -0,0 +1,318 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const treeStore = require('./model/tree-store.js');
+const util = require('./model/util.js');
+const treeNode = require('./tree-node.js');
+const useNodeExpandEventBroadcast = require('./model/useNodeExpandEventBroadcast.js');
+const useDragNode = require('./model/useDragNode.js');
+const useKeydown = require('./model/useKeydown.js');
+const tokens = require('./tokens.js');
+const tree = require('./tree.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const index = require('../../../hooks/use-locale/index.js');
+const index$1 = require('../../../hooks/use-namespace/index.js');
+const constants = require('../../form/src/constants.js');
+const isEqual = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEqual.js');
+
+const _sfc_main = vue.defineComponent({
+  name: "ElTree",
+  components: { ElTreeNode: treeNode.default },
+  props: tree.treeProps,
+  emits: tree.treeEmits,
+  setup(props, ctx) {
+    const { t } = index.useLocale();
+    const ns = index$1.useNamespace("tree");
+    const store = vue.ref(
+      new treeStore.default({
+        key: props.nodeKey,
+        data: props.data,
+        lazy: props.lazy,
+        props: props.props,
+        load: props.load,
+        currentNodeKey: props.currentNodeKey,
+        checkStrictly: props.checkStrictly,
+        checkDescendants: props.checkDescendants,
+        defaultCheckedKeys: props.defaultCheckedKeys,
+        defaultExpandedKeys: props.defaultExpandedKeys,
+        autoExpandParent: props.autoExpandParent,
+        defaultExpandAll: props.defaultExpandAll,
+        filterNodeMethod: props.filterNodeMethod
+      })
+    );
+    store.value.initialize();
+    const root = vue.ref(store.value.root);
+    const currentNode = vue.ref(null);
+    const el$ = vue.ref(null);
+    const dropIndicator$ = vue.ref(null);
+    const { broadcastExpanded } = useNodeExpandEventBroadcast.useNodeExpandEventBroadcast(props);
+    const { dragState } = useDragNode.useDragNodeHandler({
+      props,
+      ctx,
+      el$,
+      dropIndicator$,
+      store
+    });
+    useKeydown.useKeydown({ el$ }, store);
+    const instance = vue.getCurrentInstance();
+    const isSelectTree = vue.computed(() => {
+      let parent = instance == null ? void 0 : instance.parent;
+      while (parent) {
+        if (parent.type.name === "ElTreeSelect") {
+          return true;
+        }
+        parent = parent.parent;
+      }
+      return false;
+    });
+    const isEmpty = vue.computed(() => {
+      const { childNodes } = root.value;
+      return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
+    });
+    vue.watch(
+      () => props.currentNodeKey,
+      (newVal) => {
+        store.value.setCurrentNodeKey(newVal != null ? newVal : null);
+      }
+    );
+    vue.watch(
+      () => props.defaultCheckedKeys,
+      (newVal, oldVal) => {
+        if (isEqual.default(newVal, oldVal))
+          return;
+        store.value.setDefaultCheckedKey(newVal != null ? newVal : []);
+      }
+    );
+    vue.watch(
+      () => props.defaultExpandedKeys,
+      (newVal) => {
+        store.value.setDefaultExpandedKeys(newVal != null ? newVal : []);
+      }
+    );
+    vue.watch(
+      () => props.data,
+      (newVal) => {
+        store.value.setData(newVal);
+      },
+      { deep: true }
+    );
+    vue.watch(
+      () => props.checkStrictly,
+      (newVal) => {
+        store.value.checkStrictly = newVal;
+      }
+    );
+    const filter = (value) => {
+      if (!props.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      store.value.filter(value);
+    };
+    const getNodeKey$1 = (node) => {
+      return util.getNodeKey(props.nodeKey, node.data);
+    };
+    const requireNodeKey = (methodName) => {
+      if (!props.nodeKey) {
+        throw new Error(`[Tree] nodeKey is required in ${methodName}`);
+      }
+    };
+    const getNodePath = (data) => {
+      requireNodeKey("getNodePath");
+      const node = store.value.getNode(data);
+      if (!node)
+        return [];
+      const path = [node.data];
+      let parent = node.parent;
+      while (parent && parent !== root.value) {
+        path.push(parent.data);
+        parent = parent.parent;
+      }
+      return path.reverse();
+    };
+    const getCheckedNodes = (leafOnly, includeHalfChecked) => {
+      return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
+    };
+    const getCheckedKeys = (leafOnly) => {
+      return store.value.getCheckedKeys(leafOnly);
+    };
+    const getCurrentNode = () => {
+      const currentNode2 = store.value.getCurrentNode();
+      return currentNode2 ? currentNode2.data : null;
+    };
+    const getCurrentKey = () => {
+      requireNodeKey("getCurrentKey");
+      const currentNode2 = getCurrentNode();
+      return currentNode2 ? currentNode2[props.nodeKey] : null;
+    };
+    const setCheckedNodes = (nodes, leafOnly) => {
+      requireNodeKey("setCheckedNodes");
+      store.value.setCheckedNodes(nodes, leafOnly);
+    };
+    const setCheckedKeys = (keys, leafOnly) => {
+      requireNodeKey("setCheckedKeys");
+      store.value.setCheckedKeys(keys, leafOnly);
+    };
+    const setChecked = (data, checked, deep) => {
+      store.value.setChecked(data, checked, deep);
+    };
+    const getHalfCheckedNodes = () => {
+      return store.value.getHalfCheckedNodes();
+    };
+    const getHalfCheckedKeys = () => {
+      return store.value.getHalfCheckedKeys();
+    };
+    const setCurrentNode = (node, shouldAutoExpandParent = true) => {
+      requireNodeKey("setCurrentNode");
+      util.handleCurrentChange(store, ctx.emit, () => {
+        broadcastExpanded(node);
+        store.value.setUserCurrentNode(node, shouldAutoExpandParent);
+      });
+    };
+    const setCurrentKey = (key = null, shouldAutoExpandParent = true) => {
+      requireNodeKey("setCurrentKey");
+      util.handleCurrentChange(store, ctx.emit, () => {
+        broadcastExpanded();
+        store.value.setCurrentNodeKey(key, shouldAutoExpandParent);
+      });
+    };
+    const getNode = (data) => {
+      return store.value.getNode(data);
+    };
+    const remove = (data) => {
+      store.value.remove(data);
+    };
+    const append = (data, parentNode) => {
+      store.value.append(data, parentNode);
+    };
+    const insertBefore = (data, refNode) => {
+      store.value.insertBefore(data, refNode);
+    };
+    const insertAfter = (data, refNode) => {
+      store.value.insertAfter(data, refNode);
+    };
+    const handleNodeExpand = (nodeData, node, instance2) => {
+      broadcastExpanded(node);
+      ctx.emit("node-expand", nodeData, node, instance2);
+    };
+    const updateKeyChildren = (key, data) => {
+      requireNodeKey("updateKeyChild");
+      store.value.updateChildren(key, data);
+    };
+    vue.provide(tokens.ROOT_TREE_INJECTION_KEY, {
+      ctx,
+      props,
+      store,
+      root,
+      currentNode,
+      instance
+    });
+    vue.provide(constants.formItemContextKey, void 0);
+    return {
+      ns,
+      store,
+      root,
+      currentNode,
+      dragState,
+      el$,
+      dropIndicator$,
+      isEmpty,
+      filter,
+      getNodeKey: getNodeKey$1,
+      getNodePath,
+      getCheckedNodes,
+      getCheckedKeys,
+      getCurrentNode,
+      getCurrentKey,
+      setCheckedNodes,
+      setCheckedKeys,
+      setChecked,
+      getHalfCheckedNodes,
+      getHalfCheckedKeys,
+      setCurrentNode,
+      setCurrentKey,
+      t,
+      getNode,
+      remove,
+      append,
+      insertBefore,
+      insertAfter,
+      handleNodeExpand,
+      updateKeyChildren
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_tree_node = vue.resolveComponent("el-tree-node");
+  return vue.openBlock(), vue.createElementBlock(
+    "div",
+    {
+      ref: "el$",
+      class: vue.normalizeClass([
+        _ctx.ns.b(),
+        _ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
+        _ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
+        _ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
+        { [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
+      ]),
+      role: "tree"
+    },
+    [
+      (vue.openBlock(true), vue.createElementBlock(
+        vue.Fragment,
+        null,
+        vue.renderList(_ctx.root.childNodes, (child) => {
+          return vue.openBlock(), vue.createBlock(_component_el_tree_node, {
+            key: _ctx.getNodeKey(child),
+            node: child,
+            props: _ctx.props,
+            accordion: _ctx.accordion,
+            "render-after-expand": _ctx.renderAfterExpand,
+            "show-checkbox": _ctx.showCheckbox,
+            "render-content": _ctx.renderContent,
+            onNodeExpand: _ctx.handleNodeExpand
+          }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]);
+        }),
+        128
+      )),
+      _ctx.isEmpty ? (vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          key: 0,
+          class: vue.normalizeClass(_ctx.ns.e("empty-block"))
+        },
+        [
+          vue.renderSlot(_ctx.$slots, "empty", {}, () => {
+            var _a;
+            return [
+              vue.createElementVNode(
+                "span",
+                {
+                  class: vue.normalizeClass(_ctx.ns.e("empty-text"))
+                },
+                vue.toDisplayString((_a = _ctx.emptyText) != null ? _a : _ctx.t("el.tree.emptyText")),
+                3
+              )
+            ];
+          })
+        ],
+        2
+      )) : vue.createCommentVNode("v-if", true),
+      vue.withDirectives(vue.createElementVNode(
+        "div",
+        {
+          ref: "dropIndicator$",
+          class: vue.normalizeClass(_ctx.ns.e("drop-indicator"))
+        },
+        null,
+        2
+      ), [
+        [vue.vShow, _ctx.dragState.showDropIndicator]
+      ])
+    ],
+    2
+  );
+}
+var Tree = /* @__PURE__ */ pluginVue_exportHelper.default(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree.vue"]]);
+
+exports.default = Tree;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/virtual-list/src/defaults.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const HORIZONTAL = "horizontal";
+
+exports.HORIZONTAL = HORIZONTAL;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/virtual-list/src/hooks/use-wheel.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const defaults = require('../defaults.js');
+const raf = require('../../../../utils/raf.js');
+const browser = require('../../../../utils/browser.js');
+
+const useWheel = ({ atEndEdge, atStartEdge, layout }, onWheelDelta) => {
+  let frameHandle;
+  let offset = 0;
+  const hasReachedEdge = (offset2) => {
+    const edgeReached = offset2 < 0 && atStartEdge.value || offset2 > 0 && atEndEdge.value;
+    return edgeReached;
+  };
+  const onWheel = (e) => {
+    raf.cAF(frameHandle);
+    let { deltaX, deltaY } = e;
+    if (e.shiftKey && deltaY !== 0) {
+      deltaX = deltaY;
+      deltaY = 0;
+    }
+    const newOffset = layout.value === defaults.HORIZONTAL ? deltaX : deltaY;
+    if (hasReachedEdge(newOffset))
+      return;
+    offset += newOffset;
+    if (!browser.isFirefox() && newOffset !== 0) {
+      e.preventDefault();
+    }
+    frameHandle = raf.rAF(() => {
+      onWheelDelta(offset);
+      offset = 0;
+    });
+  };
+  return {
+    hasReachedEdge,
+    onWheel
+  };
+};
+
+exports.default = useWheel;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/constants/aria.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const EVENT_CODE = {
+  tab: "Tab",
+  enter: "Enter",
+  space: "Space",
+  left: "ArrowLeft",
+  up: "ArrowUp",
+  right: "ArrowRight",
+  down: "ArrowDown",
+  esc: "Escape",
+  delete: "Delete",
+  backspace: "Backspace",
+  numpadEnter: "NumpadEnter",
+  pageUp: "PageUp",
+  pageDown: "PageDown",
+  home: "Home",
+  end: "End"
+};
+
+exports.EVENT_CODE = EVENT_CODE;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/constants/date.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const datePickTypes = [
+  "year",
+  "years",
+  "month",
+  "months",
+  "date",
+  "dates",
+  "week",
+  "datetime",
+  "datetimerange",
+  "daterange",
+  "monthrange",
+  "yearrange"
+];
+
+exports.datePickTypes = datePickTypes;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/constants/event.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const UPDATE_MODEL_EVENT = "update:modelValue";
+const CHANGE_EVENT = "change";
+const INPUT_EVENT = "input";
+
+exports.CHANGE_EVENT = CHANGE_EVENT;
+exports.INPUT_EVENT = INPUT_EVENT;
+exports.UPDATE_MODEL_EVENT = UPDATE_MODEL_EVENT;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/constants/form.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const MINIMUM_INPUT_WIDTH = 11;
+const BORDER_HORIZONTAL_WIDTH = 2;
+
+exports.BORDER_HORIZONTAL_WIDTH = BORDER_HORIZONTAL_WIDTH;
+exports.MINIMUM_INPUT_WIDTH = MINIMUM_INPUT_WIDTH;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/constants/size.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const componentSizes = ["", "default", "small", "large"];
+
+exports.componentSizes = componentSizes;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/directives/click-outside/index.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const shared_esmBundler = require('../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+const types = require('../../utils/types.js');
+const index = require('../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.js');
+
+const nodeList = /* @__PURE__ */ new Map();
+if (index.isClient) {
+  let startClick;
+  document.addEventListener("mousedown", (e) => startClick = e);
+  document.addEventListener("mouseup", (e) => {
+    if (startClick) {
+      for (const handlers of nodeList.values()) {
+        for (const { documentHandler } of handlers) {
+          documentHandler(e, startClick);
+        }
+      }
+      startClick = void 0;
+    }
+  });
+}
+function createDocumentHandler(el, binding) {
+  let excludes = [];
+  if (shared_esmBundler.isArray(binding.arg)) {
+    excludes = binding.arg;
+  } else if (types.isElement(binding.arg)) {
+    excludes.push(binding.arg);
+  }
+  return function(mouseup, mousedown) {
+    const popperRef = binding.instance.popperRef;
+    const mouseUpTarget = mouseup.target;
+    const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
+    const isBound = !binding || !binding.instance;
+    const isTargetExists = !mouseUpTarget || !mouseDownTarget;
+    const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
+    const isSelf = el === mouseUpTarget;
+    const isTargetExcluded = excludes.length && excludes.some((item) => item == null ? void 0 : item.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
+    const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
+    if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
+      return;
+    }
+    binding.value(mouseup, mousedown);
+  };
+}
+const ClickOutside = {
+  beforeMount(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
+    }
+    nodeList.get(el).push({
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
+    });
+  },
+  updated(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
+    }
+    const handlers = nodeList.get(el);
+    const oldHandlerIndex = handlers.findIndex(
+      (item) => item.bindingFn === binding.oldValue
+    );
+    const newHandler = {
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
+    };
+    if (oldHandlerIndex >= 0) {
+      handlers.splice(oldHandlerIndex, 1, newHandler);
+    } else {
+      handlers.push(newHandler);
+    }
+  },
+  unmounted(el) {
+    nodeList.delete(el);
+  }
+};
+
+exports.default = ClickOutside;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/directives/repeat-click/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const shared_esmBundler = require('../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+
+const REPEAT_INTERVAL = 100;
+const REPEAT_DELAY = 600;
+const SCOPE = "_RepeatClick";
+const vRepeatClick = {
+  beforeMount(el, binding) {
+    const value = binding.value;
+    const { interval = REPEAT_INTERVAL, delay = REPEAT_DELAY } = shared_esmBundler.isFunction(
+      value
+    ) ? {} : value;
+    let intervalId;
+    let delayId;
+    const handler = () => shared_esmBundler.isFunction(value) ? value() : value.handler();
+    const clear = () => {
+      if (delayId) {
+        clearTimeout(delayId);
+        delayId = void 0;
+      }
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = void 0;
+      }
+    };
+    const start = (evt) => {
+      if (evt.button !== 0)
+        return;
+      clear();
+      handler();
+      document.addEventListener("mouseup", clear, { once: true });
+      delayId = setTimeout(() => {
+        intervalId = setInterval(() => {
+          handler();
+        }, interval);
+      }, delay);
+    };
+    el[SCOPE] = { start, clear };
+    el.addEventListener("mousedown", start);
+  },
+  unmounted(el) {
+    if (!el[SCOPE])
+      return;
+    const { start, clear } = el[SCOPE];
+    if (start) {
+      el.removeEventListener("mousedown", start);
+    }
+    if (clear) {
+      clear();
+      document.removeEventListener("mouseup", clear);
+    }
+    el[SCOPE] = null;
+  }
+};
+
+exports.REPEAT_DELAY = REPEAT_DELAY;
+exports.REPEAT_INTERVAL = REPEAT_INTERVAL;
+exports.vRepeatClick = vRepeatClick;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/hooks/use-aria/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const runtime = require('../../utils/vue/props/runtime.js');
+const pick = require('../../../../../../lodash-es@4.17.21/node_modules/lodash-es/pick.js');
+
+const ariaProps = runtime.buildProps({
+  ariaLabel: String,
+  ariaOrientation: {
+    type: String,
+    values: ["horizontal", "vertical", "undefined"]
+  },
+  ariaControls: String
+});
+const useAriaProps = (arias) => {
+  return pick.default(ariaProps, arias);
+};
+
+exports.ariaProps = ariaProps;
+exports.useAriaProps = useAriaProps;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/hooks/use-attrs/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const error = require('../../utils/error.js');
+const fromPairs = require('../../../../../../lodash-es@4.17.21/node_modules/lodash-es/fromPairs.js');
+
+const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
+const LISTENER_PREFIX = /^on[A-Z]/;
+const useAttrs = (params = {}) => {
+  const { excludeListeners = false, excludeKeys } = params;
+  const allExcludeKeys = vue.computed(() => {
+    return ((excludeKeys == null ? void 0 : excludeKeys.value) || []).concat(DEFAULT_EXCLUDE_KEYS);
+  });
+  const instance = vue.getCurrentInstance();
+  if (!instance) {
+    error.debugWarn(
+      "use-attrs",
+      "getCurrentInstance() returned null. useAttrs() must be called at the top of a setup function"
+    );
+    return vue.computed(() => ({}));
+  }
+  return vue.computed(
+    () => {
+      var _a;
+      return fromPairs.default(
+        Object.entries((_a = instance.proxy) == null ? void 0 : _a.$attrs).filter(
+          ([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))
+        )
+      );
+    }
+  );
+};
+
+exports.useAttrs = useAttrs;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/hooks/use-calc-input-width/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const index = require('../../../../../../@vueuse_core@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/index.js');
+const form = require('../../constants/form.js');
+
+function useCalcInputWidth() {
+  const calculatorRef = vue.shallowRef();
+  const calculatorWidth = vue.ref(0);
+  const inputStyle = vue.computed(() => ({
+    minWidth: `${Math.max(calculatorWidth.value, form.MINIMUM_INPUT_WIDTH)}px`
+  }));
+  const resetCalculatorWidth = () => {
+    var _a, _b;
+    calculatorWidth.value = (_b = (_a = calculatorRef.value) == null ? void 0 : _a.getBoundingClientRect().width) != null ? _b : 0;
+  };
+  index.useResizeObserver(calculatorRef, resetCalculatorWidth);
+  return {
+    calculatorRef,
+    calculatorWidth,
+    inputStyle
+  };
+}
+
+exports.useCalcInputWidth = useCalcInputWidth;