@funcho/ui 1.0.0

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/input-number/src/input-number2.mjs

@@ -0,0 +1,419 @@
+import { defineComponent, ref, reactive, computed, watch, onMounted, onUpdated, createElementBlock, openBlock, withModifiers, normalizeClass, unref, withDirectives, createCommentVNode, createVNode, withKeys, renderSlot, withCtx, createBlock, createSlots } from 'vue';
+import { ElInput } from '../../input/index.mjs';
+import { ElIcon } from '../../icon/index.mjs';
+import { ArrowDown as arrow_down_default, Minus as minus_default, ArrowUp as arrow_up_default, Plus as plus_default } from '../../../../../../../@element-plus_icons-vue@2.3.2_vue@3.5.22_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.mjs';
+import { inputNumberEmits, inputNumberProps } from './input-number.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { vRepeatClick } from '../../../directives/repeat-click/index.mjs';
+import { getEventCode, getEventKey } from '../../../utils/dom/event.mjs';
+import { useLocale } from '../../../hooks/use-locale/index.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+import { useFormItem } from '../../form/src/hooks/use-form-item.mjs';
+import { isNumber, isUndefined } from '../../../utils/types.mjs';
+import { debugWarn, throwError } from '../../../utils/error.mjs';
+import { useFormSize, useFormDisabled } from '../../form/src/hooks/use-form-common-props.mjs';
+import { UPDATE_MODEL_EVENT, INPUT_EVENT, CHANGE_EVENT } from '../../../constants/event.mjs';
+import { EVENT_CODE } from '../../../constants/aria.mjs';
+import { isString } from '../../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.mjs';
+import isNil from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isNil.mjs';
+
+const _hoisted_1 = ["aria-label"];
+const _hoisted_2 = ["aria-label"];
+const _sfc_main = defineComponent({
+  ...{
+    name: "ElInputNumber"
+  },
+  __name: "input-number",
+  props: inputNumberProps,
+  emits: inputNumberEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { t } = useLocale();
+    const ns = useNamespace("input-number");
+    const input = ref();
+    const data = reactive({
+      currentValue: props.modelValue,
+      userInput: null
+    });
+    const { formItem } = useFormItem();
+    const minDisabled = computed(
+      () => isNumber(props.modelValue) && props.modelValue <= props.min
+    );
+    const maxDisabled = computed(
+      () => isNumber(props.modelValue) && props.modelValue >= props.max
+    );
+    const numPrecision = computed(() => {
+      const stepPrecision = getPrecision(props.step);
+      if (!isUndefined(props.precision)) {
+        if (stepPrecision > props.precision) {
+          debugWarn(
+            "InputNumber",
+            "precision should not be less than the decimal places of step"
+          );
+        }
+        return props.precision;
+      } else {
+        return Math.max(getPrecision(props.modelValue), stepPrecision);
+      }
+    });
+    const controlsAtRight = computed(() => {
+      return props.controls && props.controlsPosition === "right";
+    });
+    const inputNumberSize = useFormSize();
+    const inputNumberDisabled = useFormDisabled();
+    const displayValue = computed(() => {
+      if (data.userInput !== null) {
+        return data.userInput;
+      }
+      let currentValue = data.currentValue;
+      if (isNil(currentValue))
+        return "";
+      if (isNumber(currentValue)) {
+        if (Number.isNaN(currentValue))
+          return "";
+        if (!isUndefined(props.precision)) {
+          currentValue = currentValue.toFixed(props.precision);
+        }
+      }
+      return currentValue;
+    });
+    const toPrecision = (num, pre) => {
+      if (isUndefined(pre))
+        pre = numPrecision.value;
+      if (pre === 0)
+        return Math.round(num);
+      let snum = String(num);
+      const pointPos = snum.indexOf(".");
+      if (pointPos === -1)
+        return num;
+      const nums = snum.replace(".", "").split("");
+      const datum = nums[pointPos + pre];
+      if (!datum)
+        return num;
+      const length = snum.length;
+      if (snum.charAt(length - 1) === "5") {
+        snum = `${snum.slice(0, Math.max(0, length - 1))}6`;
+      }
+      return Number.parseFloat(Number(snum).toFixed(pre));
+    };
+    const getPrecision = (value) => {
+      if (isNil(value))
+        return 0;
+      const valueString = value.toString();
+      const dotPosition = valueString.indexOf(".");
+      let precision = 0;
+      if (dotPosition !== -1) {
+        precision = valueString.length - dotPosition - 1;
+      }
+      return precision;
+    };
+    const ensurePrecision = (val, coefficient = 1) => {
+      if (!isNumber(val))
+        return data.currentValue;
+      if (val >= Number.MAX_SAFE_INTEGER && coefficient === 1) {
+        debugWarn(
+          "InputNumber",
+          "The value has reached the maximum safe integer limit."
+        );
+        return val;
+      } else if (val <= Number.MIN_SAFE_INTEGER && coefficient === -1) {
+        debugWarn(
+          "InputNumber",
+          "The value has reached the minimum safe integer limit."
+        );
+        return val;
+      }
+      return toPrecision(val + props.step * coefficient);
+    };
+    const handleKeydown = (event) => {
+      const code = getEventCode(event);
+      const key = getEventKey(event);
+      if (props.disabledScientific && ["e", "E"].includes(key)) {
+        event.preventDefault();
+        return;
+      }
+      switch (code) {
+        case EVENT_CODE.up: {
+          event.preventDefault();
+          increase();
+          break;
+        }
+        case EVENT_CODE.down: {
+          event.preventDefault();
+          decrease();
+          break;
+        }
+      }
+    };
+    const increase = () => {
+      if (props.readonly || inputNumberDisabled.value || maxDisabled.value)
+        return;
+      const value = Number(displayValue.value) || 0;
+      const newVal = ensurePrecision(value);
+      setCurrentValue(newVal);
+      emit(INPUT_EVENT, data.currentValue);
+      setCurrentValueToModelValue();
+    };
+    const decrease = () => {
+      if (props.readonly || inputNumberDisabled.value || minDisabled.value)
+        return;
+      const value = Number(displayValue.value) || 0;
+      const newVal = ensurePrecision(value, -1);
+      setCurrentValue(newVal);
+      emit(INPUT_EVENT, data.currentValue);
+      setCurrentValueToModelValue();
+    };
+    const verifyValue = (value, update) => {
+      const { max, min, step, precision, stepStrictly, valueOnClear } = props;
+      if (max < min) {
+        throwError("InputNumber", "min should not be greater than max.");
+      }
+      let newVal = Number(value);
+      if (isNil(value) || Number.isNaN(newVal)) {
+        return null;
+      }
+      if (value === "") {
+        if (valueOnClear === null) {
+          return null;
+        }
+        newVal = isString(valueOnClear) ? { min, max }[valueOnClear] : valueOnClear;
+      }
+      if (stepStrictly) {
+        newVal = toPrecision(
+          Math.round(toPrecision(newVal / step)) * step,
+          precision
+        );
+        if (newVal !== value) {
+          update && emit(UPDATE_MODEL_EVENT, newVal);
+        }
+      }
+      if (!isUndefined(precision)) {
+        newVal = toPrecision(newVal, precision);
+      }
+      if (newVal > max || newVal < min) {
+        newVal = newVal > max ? max : min;
+        update && emit(UPDATE_MODEL_EVENT, newVal);
+      }
+      return newVal;
+    };
+    const setCurrentValue = (value, emitChange = true) => {
+      var _a;
+      const oldVal = data.currentValue;
+      const newVal = verifyValue(value);
+      if (!emitChange) {
+        emit(UPDATE_MODEL_EVENT, newVal);
+        return;
+      }
+      data.userInput = null;
+      if (oldVal === newVal && value)
+        return;
+      emit(UPDATE_MODEL_EVENT, newVal);
+      if (oldVal !== newVal) {
+        emit(CHANGE_EVENT, newVal, oldVal);
+      }
+      if (props.validateEvent) {
+        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn(err));
+      }
+      data.currentValue = newVal;
+    };
+    const handleInput = (value) => {
+      data.userInput = value;
+      const newVal = value === "" ? null : Number(value);
+      emit(INPUT_EVENT, newVal);
+      setCurrentValue(newVal, false);
+    };
+    const handleInputChange = (value) => {
+      const newVal = value !== "" ? Number(value) : "";
+      if (isNumber(newVal) && !Number.isNaN(newVal) || value === "") {
+        setCurrentValue(newVal);
+      }
+      setCurrentValueToModelValue();
+      data.userInput = null;
+    };
+    const focus = () => {
+      var _a, _b;
+      (_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
+    };
+    const blur = () => {
+      var _a, _b;
+      (_b = (_a = input.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
+    };
+    const handleFocus = (event) => {
+      emit("focus", event);
+    };
+    const handleBlur = (event) => {
+      var _a, _b;
+      data.userInput = null;
+      if (data.currentValue === null && ((_a = input.value) == null ? void 0 : _a.input)) {
+        input.value.input.value = "";
+      }
+      emit("blur", event);
+      if (props.validateEvent) {
+        (_b = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _b.call(formItem, "blur").catch((err) => debugWarn(err));
+      }
+    };
+    const setCurrentValueToModelValue = () => {
+      if (data.currentValue !== props.modelValue) {
+        data.currentValue = props.modelValue;
+      }
+    };
+    const handleWheel = (e) => {
+      if (document.activeElement === e.target)
+        e.preventDefault();
+    };
+    watch(
+      () => props.modelValue,
+      (value, oldValue) => {
+        const newValue = verifyValue(value, true);
+        if (data.userInput === null && newValue !== oldValue) {
+          data.currentValue = newValue;
+        }
+      },
+      { immediate: true }
+    );
+    watch(
+      () => props.precision,
+      () => {
+        data.currentValue = verifyValue(props.modelValue);
+      }
+    );
+    onMounted(() => {
+      var _a;
+      const { min, max, modelValue } = props;
+      const innerInput = (_a = input.value) == null ? void 0 : _a.input;
+      innerInput.setAttribute("role", "spinbutton");
+      if (Number.isFinite(max)) {
+        innerInput.setAttribute("aria-valuemax", String(max));
+      } else {
+        innerInput.removeAttribute("aria-valuemax");
+      }
+      if (Number.isFinite(min)) {
+        innerInput.setAttribute("aria-valuemin", String(min));
+      } else {
+        innerInput.removeAttribute("aria-valuemin");
+      }
+      innerInput.setAttribute(
+        "aria-valuenow",
+        data.currentValue || data.currentValue === 0 ? String(data.currentValue) : ""
+      );
+      innerInput.setAttribute("aria-disabled", String(inputNumberDisabled.value));
+      if (!isNumber(modelValue) && modelValue != null) {
+        let val = Number(modelValue);
+        if (Number.isNaN(val)) {
+          val = null;
+        }
+        emit(UPDATE_MODEL_EVENT, val);
+      }
+      innerInput.addEventListener("wheel", handleWheel, { passive: false });
+    });
+    onUpdated(() => {
+      var _a, _b;
+      const innerInput = (_a = input.value) == null ? void 0 : _a.input;
+      innerInput == null ? void 0 : innerInput.setAttribute("aria-valuenow", `${(_b = data.currentValue) != null ? _b : ""}`);
+    });
+    __expose({
+      focus,
+      blur
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass([
+            unref(ns).b(),
+            unref(ns).m(unref(inputNumberSize)),
+            unref(ns).is("disabled", unref(inputNumberDisabled)),
+            unref(ns).is("without-controls", !_ctx.controls),
+            unref(ns).is("controls-right", controlsAtRight.value),
+            unref(ns).is(_ctx.align, !!_ctx.align)
+          ]),
+          onDragstart: _cache[0] || (_cache[0] = withModifiers(() => {
+          }, ["prevent"]))
+        },
+        [
+          _ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
+            key: 0,
+            role: "button",
+            "aria-label": unref(t)("el.inputNumber.decrease"),
+            class: normalizeClass([unref(ns).e("decrease"), unref(ns).is("disabled", minDisabled.value)]),
+            onKeydown: withKeys(decrease, ["enter"])
+          }, [
+            renderSlot(_ctx.$slots, "decrease-icon", {}, () => [
+              createVNode(unref(ElIcon), null, {
+                default: withCtx(() => [
+                  controlsAtRight.value ? (openBlock(), createBlock(unref(arrow_down_default), { key: 0 })) : (openBlock(), createBlock(unref(minus_default), { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 42, _hoisted_1)), [
+            [unref(vRepeatClick), decrease]
+          ]) : createCommentVNode("v-if", true),
+          _ctx.controls ? withDirectives((openBlock(), createElementBlock("span", {
+            key: 1,
+            role: "button",
+            "aria-label": unref(t)("el.inputNumber.increase"),
+            class: normalizeClass([unref(ns).e("increase"), unref(ns).is("disabled", maxDisabled.value)]),
+            onKeydown: withKeys(increase, ["enter"])
+          }, [
+            renderSlot(_ctx.$slots, "increase-icon", {}, () => [
+              createVNode(unref(ElIcon), null, {
+                default: withCtx(() => [
+                  controlsAtRight.value ? (openBlock(), createBlock(unref(arrow_up_default), { key: 0 })) : (openBlock(), createBlock(unref(plus_default), { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 42, _hoisted_2)), [
+            [unref(vRepeatClick), increase]
+          ]) : createCommentVNode("v-if", true),
+          createVNode(unref(ElInput), {
+            id: _ctx.id,
+            ref_key: "input",
+            ref: input,
+            type: "number",
+            step: _ctx.step,
+            "model-value": displayValue.value,
+            placeholder: _ctx.placeholder,
+            readonly: _ctx.readonly,
+            disabled: unref(inputNumberDisabled),
+            size: unref(inputNumberSize),
+            max: _ctx.max,
+            min: _ctx.min,
+            name: _ctx.name,
+            "aria-label": _ctx.ariaLabel,
+            "validate-event": false,
+            inputmode: _ctx.inputmode,
+            onKeydown: handleKeydown,
+            onBlur: handleBlur,
+            onFocus: handleFocus,
+            onInput: handleInput,
+            onChange: handleInputChange
+          }, createSlots({
+            _: 2
+          }, [
+            _ctx.$slots.prefix ? {
+              name: "prefix",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "prefix")
+              ]),
+              key: "0"
+            } : void 0,
+            _ctx.$slots.suffix ? {
+              name: "suffix",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "suffix")
+              ]),
+              key: "1"
+            } : void 0
+          ]), 1032, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "aria-label", "inputmode"])
+        ],
+        34
+      );
+    };
+  }
+});
+var InputNumber = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/input-number/src/input-number.vue"]]);
+
+export { InputNumber as default };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/overlay/index.mjs

@@ -0,0 +1,6 @@
+import Overlay from './src/overlay.mjs';
+export { overlayEmits, overlayProps } from './src/overlay.mjs';
+
+const ElOverlay = Overlay;
+
+export { ElOverlay, ElOverlay as default };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/overlay/src/overlay.mjs

@@ -0,0 +1,74 @@
+import { defineComponent, createVNode, h, renderSlot } from 'vue';
+import { useSameTarget } from '../../../hooks/use-same-target/index.mjs';
+import { PatchFlags } from '../../../utils/vue/vnode.mjs';
+import { buildProps, definePropType } from '../../../utils/vue/props/runtime.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+
+const overlayProps = buildProps({
+  mask: {
+    type: Boolean,
+    default: true
+  },
+  customMaskEvent: Boolean,
+  overlayClass: {
+    type: definePropType([
+      String,
+      Array,
+      Object
+    ])
+  },
+  zIndex: {
+    type: definePropType([String, Number])
+  }
+});
+const overlayEmits = {
+  click: (evt) => evt instanceof MouseEvent
+};
+const BLOCK = "overlay";
+var Overlay = defineComponent({
+  name: "ElOverlay",
+  props: overlayProps,
+  emits: overlayEmits,
+  setup(props, { slots, emit }) {
+    const ns = useNamespace(BLOCK);
+    const onMaskClick = (e) => {
+      emit("click", e);
+    };
+    const { onClick, onMousedown, onMouseup } = useSameTarget(
+      props.customMaskEvent ? void 0 : onMaskClick
+    );
+    return () => {
+      return props.mask ? createVNode(
+        "div",
+        {
+          class: [ns.b(), props.overlayClass],
+          style: {
+            zIndex: props.zIndex
+          },
+          onClick,
+          onMousedown,
+          onMouseup
+        },
+        [renderSlot(slots, "default")],
+        PatchFlags.STYLE | PatchFlags.CLASS | PatchFlags.PROPS,
+        ["onClick", "onMouseup", "onMousedown"]
+      ) : h(
+        "div",
+        {
+          class: props.overlayClass,
+          style: {
+            zIndex: props.zIndex,
+            position: "fixed",
+            top: "0px",
+            right: "0px",
+            bottom: "0px",
+            left: "0px"
+          }
+        },
+        [renderSlot(slots, "default")]
+      );
+    };
+  }
+});
+
+export { Overlay as default, overlayEmits, overlayProps };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/popper/index.mjs

@@ -0,0 +1,6 @@
+import Popper from './src/popper2.mjs';
+import { withInstall } from '../../utils/vue/install.mjs';
+
+const ElPopper = withInstall(Popper);
+
+export { ElPopper, ElPopper as default };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/popper/src/arrow.mjs

@@ -0,0 +1,10 @@
+import { buildProps } from '../../../utils/vue/props/runtime.mjs';
+
+const popperArrowProps = buildProps({
+  arrowOffset: {
+    type: Number,
+    default: 5
+  }
+});
+
+export { popperArrowProps };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/popper/src/arrow2.mjs

@@ -0,0 +1,42 @@
+import { defineComponent, inject, onBeforeUnmount, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref } from 'vue';
+import { POPPER_CONTENT_INJECTION_KEY } from './constants.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+
+const _sfc_main = defineComponent({
+  ...{
+    name: "ElPopperArrow",
+    inheritAttrs: false
+  },
+  __name: "arrow",
+  setup(__props, { expose: __expose }) {
+    const ns = useNamespace("popper");
+    const { arrowRef, arrowStyle } = inject(
+      POPPER_CONTENT_INJECTION_KEY,
+      void 0
+    );
+    onBeforeUnmount(() => {
+      arrowRef.value = void 0;
+    });
+    __expose({
+      arrowRef
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "span",
+        {
+          ref_key: "arrowRef",
+          ref: arrowRef,
+          class: normalizeClass(unref(ns).e("arrow")),
+          style: normalizeStyle(unref(arrowStyle)),
+          "data-popper-arrow": ""
+        },
+        null,
+        6
+      );
+    };
+  }
+});
+var ElPopperArrow = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/arrow.vue"]]);
+
+export { ElPopperArrow as default };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/popper/src/composables/use-content-dom.mjs

@@ -0,0 +1,50 @@
+import { computed, unref, ref } from 'vue';
+import { useZIndex } from '../../../../hooks/use-z-index/index.mjs';
+import { useNamespace } from '../../../../hooks/use-namespace/index.mjs';
+import { isNumber } from '../../../../utils/types.mjs';
+
+const usePopperContentDOM = (props, {
+  attributes,
+  styles,
+  role
+}) => {
+  const { nextZIndex } = useZIndex();
+  const ns = useNamespace("popper");
+  const contentAttrs = computed(() => unref(attributes).popper);
+  const contentZIndex = ref(
+    isNumber(props.zIndex) ? props.zIndex : nextZIndex()
+  );
+  const contentClass = computed(() => [
+    ns.b(),
+    ns.is("pure", props.pure),
+    ns.is(props.effect),
+    props.popperClass
+  ]);
+  const contentStyle = computed(() => {
+    return [
+      { zIndex: unref(contentZIndex) },
+      unref(styles).popper,
+      props.popperStyle || {}
+    ];
+  });
+  const ariaModal = computed(
+    () => role.value === "dialog" ? "false" : void 0
+  );
+  const arrowStyle = computed(
+    () => unref(styles).arrow || {}
+  );
+  const updateZIndex = () => {
+    contentZIndex.value = isNumber(props.zIndex) ? props.zIndex : nextZIndex();
+  };
+  return {
+    ariaModal,
+    arrowStyle,
+    contentAttrs,
+    contentClass,
+    contentStyle,
+    contentZIndex,
+    updateZIndex
+  };
+};
+
+export { usePopperContentDOM };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/popper/src/composables/use-content.mjs

@@ -0,0 +1,79 @@
+import { inject, ref, computed, unref, watch, onMounted, onBeforeUnmount } from 'vue';
+import { POPPER_INJECTION_KEY } from '../constants.mjs';
+import { buildPopperOptions, unwrapMeasurableEl } from '../utils.mjs';
+import { usePopper } from '../../../../hooks/use-popper/index.mjs';
+import isUndefined from '../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs';
+
+const DEFAULT_ARROW_OFFSET = 0;
+const usePopperContent = (props) => {
+  const { popperInstanceRef, contentRef, triggerRef, role } = inject(
+    POPPER_INJECTION_KEY,
+    void 0
+  );
+  const arrowRef = ref();
+  const arrowOffset = computed(() => props.arrowOffset);
+  const eventListenerModifier = computed(() => {
+    return {
+      name: "eventListeners",
+      enabled: !!props.visible
+    };
+  });
+  const arrowModifier = computed(() => {
+    var _a;
+    const arrowEl = unref(arrowRef);
+    const offset = (_a = unref(arrowOffset)) != null ? _a : DEFAULT_ARROW_OFFSET;
+    return {
+      name: "arrow",
+      enabled: !isUndefined(arrowEl),
+      options: {
+        element: arrowEl,
+        padding: offset
+      }
+    };
+  });
+  const options = computed(() => {
+    return {
+      onFirstUpdate: () => {
+        update();
+      },
+      ...buildPopperOptions(props, [
+        unref(arrowModifier),
+        unref(eventListenerModifier)
+      ])
+    };
+  });
+  const computedReference = computed(
+    () => unwrapMeasurableEl(props.referenceEl) || unref(triggerRef)
+  );
+  const { attributes, state, styles, update, forceUpdate, instanceRef } = usePopper(computedReference, contentRef, options);
+  watch(instanceRef, (instance) => popperInstanceRef.value = instance, {
+    flush: "sync"
+  });
+  onMounted(() => {
+    watch(
+      () => {
+        var _a, _b;
+        return (_b = (_a = unref(computedReference)) == null ? void 0 : _a.getBoundingClientRect) == null ? void 0 : _b.call(_a);
+      },
+      () => {
+        update();
+      }
+    );
+  });
+  onBeforeUnmount(() => {
+    popperInstanceRef.value = void 0;
+  });
+  return {
+    attributes,
+    arrowRef,
+    contentRef,
+    instanceRef,
+    state,
+    styles,
+    role,
+    forceUpdate,
+    update
+  };
+};
+
+export { usePopperContent };