@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/input-number/src/input-number2.js

@@ -0,0 +1,423 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const index$5 = require('../../input/index.js');
+const index$2 = require('../../icon/index.js');
+const index$3 = require('../../../../../../../@element-plus_icons-vue@2.3.2_vue@3.5.22_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.js');
+const inputNumber = require('./input-number.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const index$4 = require('../../../directives/repeat-click/index.js');
+const event$1 = require('../../../utils/dom/event.js');
+const index = require('../../../hooks/use-locale/index.js');
+const index$1 = require('../../../hooks/use-namespace/index.js');
+const useFormItem = require('../../form/src/hooks/use-form-item.js');
+const types = require('../../../utils/types.js');
+const error = require('../../../utils/error.js');
+const useFormCommonProps = require('../../form/src/hooks/use-form-common-props.js');
+const event = require('../../../constants/event.js');
+const aria = require('../../../constants/aria.js');
+const shared_esmBundler = require('../../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+const isNil = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isNil.js');
+
+const _hoisted_1 = ["aria-label"];
+const _hoisted_2 = ["aria-label"];
+const _sfc_main = vue.defineComponent({
+  ...{
+    name: "ElInputNumber"
+  },
+  __name: "input-number",
+  props: inputNumber.inputNumberProps,
+  emits: inputNumber.inputNumberEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { t } = index.useLocale();
+    const ns = index$1.useNamespace("input-number");
+    const input = vue.ref();
+    const data = vue.reactive({
+      currentValue: props.modelValue,
+      userInput: null
+    });
+    const { formItem } = useFormItem.useFormItem();
+    const minDisabled = vue.computed(
+      () => types.isNumber(props.modelValue) && props.modelValue <= props.min
+    );
+    const maxDisabled = vue.computed(
+      () => types.isNumber(props.modelValue) && props.modelValue >= props.max
+    );
+    const numPrecision = vue.computed(() => {
+      const stepPrecision = getPrecision(props.step);
+      if (!types.isUndefined(props.precision)) {
+        if (stepPrecision > props.precision) {
+          error.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 = vue.computed(() => {
+      return props.controls && props.controlsPosition === "right";
+    });
+    const inputNumberSize = useFormCommonProps.useFormSize();
+    const inputNumberDisabled = useFormCommonProps.useFormDisabled();
+    const displayValue = vue.computed(() => {
+      if (data.userInput !== null) {
+        return data.userInput;
+      }
+      let currentValue = data.currentValue;
+      if (isNil.default(currentValue))
+        return "";
+      if (types.isNumber(currentValue)) {
+        if (Number.isNaN(currentValue))
+          return "";
+        if (!types.isUndefined(props.precision)) {
+          currentValue = currentValue.toFixed(props.precision);
+        }
+      }
+      return currentValue;
+    });
+    const toPrecision = (num, pre) => {
+      if (types.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.default(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 (!types.isNumber(val))
+        return data.currentValue;
+      if (val >= Number.MAX_SAFE_INTEGER && coefficient === 1) {
+        error.debugWarn(
+          "InputNumber",
+          "The value has reached the maximum safe integer limit."
+        );
+        return val;
+      } else if (val <= Number.MIN_SAFE_INTEGER && coefficient === -1) {
+        error.debugWarn(
+          "InputNumber",
+          "The value has reached the minimum safe integer limit."
+        );
+        return val;
+      }
+      return toPrecision(val + props.step * coefficient);
+    };
+    const handleKeydown = (event) => {
+      const code = event$1.getEventCode(event);
+      const key = event$1.getEventKey(event);
+      if (props.disabledScientific && ["e", "E"].includes(key)) {
+        event.preventDefault();
+        return;
+      }
+      switch (code) {
+        case aria.EVENT_CODE.up: {
+          event.preventDefault();
+          increase();
+          break;
+        }
+        case aria.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(event.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(event.INPUT_EVENT, data.currentValue);
+      setCurrentValueToModelValue();
+    };
+    const verifyValue = (value, update) => {
+      const { max, min, step, precision, stepStrictly, valueOnClear } = props;
+      if (max < min) {
+        error.throwError("InputNumber", "min should not be greater than max.");
+      }
+      let newVal = Number(value);
+      if (isNil.default(value) || Number.isNaN(newVal)) {
+        return null;
+      }
+      if (value === "") {
+        if (valueOnClear === null) {
+          return null;
+        }
+        newVal = shared_esmBundler.isString(valueOnClear) ? { min, max }[valueOnClear] : valueOnClear;
+      }
+      if (stepStrictly) {
+        newVal = toPrecision(
+          Math.round(toPrecision(newVal / step)) * step,
+          precision
+        );
+        if (newVal !== value) {
+          update && emit(event.UPDATE_MODEL_EVENT, newVal);
+        }
+      }
+      if (!types.isUndefined(precision)) {
+        newVal = toPrecision(newVal, precision);
+      }
+      if (newVal > max || newVal < min) {
+        newVal = newVal > max ? max : min;
+        update && emit(event.UPDATE_MODEL_EVENT, newVal);
+      }
+      return newVal;
+    };
+    const setCurrentValue = (value, emitChange = true) => {
+      var _a;
+      const oldVal = data.currentValue;
+      const newVal = verifyValue(value);
+      if (!emitChange) {
+        emit(event.UPDATE_MODEL_EVENT, newVal);
+        return;
+      }
+      data.userInput = null;
+      if (oldVal === newVal && value)
+        return;
+      emit(event.UPDATE_MODEL_EVENT, newVal);
+      if (oldVal !== newVal) {
+        emit(event.CHANGE_EVENT, newVal, oldVal);
+      }
+      if (props.validateEvent) {
+        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => error.debugWarn(err));
+      }
+      data.currentValue = newVal;
+    };
+    const handleInput = (value) => {
+      data.userInput = value;
+      const newVal = value === "" ? null : Number(value);
+      emit(event.INPUT_EVENT, newVal);
+      setCurrentValue(newVal, false);
+    };
+    const handleInputChange = (value) => {
+      const newVal = value !== "" ? Number(value) : "";
+      if (types.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) => error.debugWarn(err));
+      }
+    };
+    const setCurrentValueToModelValue = () => {
+      if (data.currentValue !== props.modelValue) {
+        data.currentValue = props.modelValue;
+      }
+    };
+    const handleWheel = (e) => {
+      if (document.activeElement === e.target)
+        e.preventDefault();
+    };
+    vue.watch(
+      () => props.modelValue,
+      (value, oldValue) => {
+        const newValue = verifyValue(value, true);
+        if (data.userInput === null && newValue !== oldValue) {
+          data.currentValue = newValue;
+        }
+      },
+      { immediate: true }
+    );
+    vue.watch(
+      () => props.precision,
+      () => {
+        data.currentValue = verifyValue(props.modelValue);
+      }
+    );
+    vue.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 (!types.isNumber(modelValue) && modelValue != null) {
+        let val = Number(modelValue);
+        if (Number.isNaN(val)) {
+          val = null;
+        }
+        emit(event.UPDATE_MODEL_EVENT, val);
+      }
+      innerInput.addEventListener("wheel", handleWheel, { passive: false });
+    });
+    vue.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 vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          class: vue.normalizeClass([
+            vue.unref(ns).b(),
+            vue.unref(ns).m(vue.unref(inputNumberSize)),
+            vue.unref(ns).is("disabled", vue.unref(inputNumberDisabled)),
+            vue.unref(ns).is("without-controls", !_ctx.controls),
+            vue.unref(ns).is("controls-right", controlsAtRight.value),
+            vue.unref(ns).is(_ctx.align, !!_ctx.align)
+          ]),
+          onDragstart: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+          }, ["prevent"]))
+        },
+        [
+          _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
+            key: 0,
+            role: "button",
+            "aria-label": vue.unref(t)("el.inputNumber.decrease"),
+            class: vue.normalizeClass([vue.unref(ns).e("decrease"), vue.unref(ns).is("disabled", minDisabled.value)]),
+            onKeydown: vue.withKeys(decrease, ["enter"])
+          }, [
+            vue.renderSlot(_ctx.$slots, "decrease-icon", {}, () => [
+              vue.createVNode(vue.unref(index$2.ElIcon), null, {
+                default: vue.withCtx(() => [
+                  controlsAtRight.value ? (vue.openBlock(), vue.createBlock(vue.unref(index$3.ArrowDown), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(index$3.Minus), { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 42, _hoisted_1)), [
+            [vue.unref(index$4.vRepeatClick), decrease]
+          ]) : vue.createCommentVNode("v-if", true),
+          _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
+            key: 1,
+            role: "button",
+            "aria-label": vue.unref(t)("el.inputNumber.increase"),
+            class: vue.normalizeClass([vue.unref(ns).e("increase"), vue.unref(ns).is("disabled", maxDisabled.value)]),
+            onKeydown: vue.withKeys(increase, ["enter"])
+          }, [
+            vue.renderSlot(_ctx.$slots, "increase-icon", {}, () => [
+              vue.createVNode(vue.unref(index$2.ElIcon), null, {
+                default: vue.withCtx(() => [
+                  controlsAtRight.value ? (vue.openBlock(), vue.createBlock(vue.unref(index$3.ArrowUp), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(index$3.Plus), { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 42, _hoisted_2)), [
+            [vue.unref(index$4.vRepeatClick), increase]
+          ]) : vue.createCommentVNode("v-if", true),
+          vue.createVNode(vue.unref(index$5.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: vue.unref(inputNumberDisabled),
+            size: vue.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
+          }, vue.createSlots({
+            _: 2
+          }, [
+            _ctx.$slots.prefix ? {
+              name: "prefix",
+              fn: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "prefix")
+              ]),
+              key: "0"
+            } : void 0,
+            _ctx.$slots.suffix ? {
+              name: "suffix",
+              fn: vue.withCtx(() => [
+                vue.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__ */ pluginVue_exportHelper.default(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/input-number/src/input-number.vue"]]);
+
+exports.default = InputNumber;

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

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const overlay = require('./src/overlay.js');
+
+const ElOverlay = overlay.default;
+
+exports.overlayEmits = overlay.overlayEmits;
+exports.overlayProps = overlay.overlayProps;
+exports.ElOverlay = ElOverlay;
+exports.default = ElOverlay;

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

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

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

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const popper2 = require('./src/popper2.js');
+const install = require('../../utils/vue/install.js');
+
+const ElPopper = install.withInstall(popper2.default);
+
+exports.ElPopper = ElPopper;
+exports.default = ElPopper;

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

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const runtime = require('../../../utils/vue/props/runtime.js');
+
+const popperArrowProps = runtime.buildProps({
+  arrowOffset: {
+    type: Number,
+    default: 5
+  }
+});
+
+exports.popperArrowProps = popperArrowProps;

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

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

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

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