@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/hooks/use-composition/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const i18n = require('../../utils/i18n.js');
+
+function useComposition({
+  afterComposition,
+  emit
+}) {
+  const isComposing = vue.ref(false);
+  const handleCompositionStart = (event) => {
+    emit == null ? void 0 : emit("compositionstart", event);
+    isComposing.value = true;
+  };
+  const handleCompositionUpdate = (event) => {
+    var _a;
+    emit == null ? void 0 : emit("compositionupdate", event);
+    const text = (_a = event.target) == null ? void 0 : _a.value;
+    const lastCharacter = text[text.length - 1] || "";
+    isComposing.value = !i18n.isKorean(lastCharacter);
+  };
+  const handleCompositionEnd = (event) => {
+    emit == null ? void 0 : emit("compositionend", event);
+    if (isComposing.value) {
+      isComposing.value = false;
+      vue.nextTick(() => afterComposition(event));
+    }
+  };
+  const handleComposition = (event) => {
+    event.type === "compositionend" ? handleCompositionEnd(event) : handleCompositionUpdate(event);
+  };
+  return {
+    isComposing,
+    handleComposition,
+    handleCompositionStart,
+    handleCompositionUpdate,
+    handleCompositionEnd
+  };
+}
+
+exports.useComposition = useComposition;

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

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function useCursor(input) {
+  let selectionInfo;
+  function recordCursor() {
+    if (input.value == void 0)
+      return;
+    const { selectionStart, selectionEnd, value } = input.value;
+    if (selectionStart == null || selectionEnd == null)
+      return;
+    const beforeTxt = value.slice(0, Math.max(0, selectionStart));
+    const afterTxt = value.slice(Math.max(0, selectionEnd));
+    selectionInfo = {
+      selectionStart,
+      selectionEnd,
+      value,
+      beforeTxt,
+      afterTxt
+    };
+  }
+  function setCursor() {
+    if (input.value == void 0 || selectionInfo == void 0)
+      return;
+    const { value } = input.value;
+    const { beforeTxt, afterTxt, selectionStart } = selectionInfo;
+    if (beforeTxt == void 0 || afterTxt == void 0 || selectionStart == void 0)
+      return;
+    let startPos = value.length;
+    if (value.endsWith(afterTxt)) {
+      startPos = value.length - afterTxt.length;
+    } else if (value.startsWith(beforeTxt)) {
+      startPos = beforeTxt.length;
+    } else {
+      const beforeLastChar = beforeTxt[selectionStart - 1];
+      const newIndex = value.indexOf(beforeLastChar, selectionStart - 1);
+      if (newIndex !== -1) {
+        startPos = newIndex + 1;
+      }
+    }
+    input.value.setSelectionRange(startPos, startPos);
+  }
+  return [recordCursor, setCursor];
+}
+
+exports.useCursor = useCursor;

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

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const index = require('../use-timeout/index.js');
+const runtime = require('../../utils/vue/props/runtime.js');
+const types = require('../../utils/types.js');
+
+const useDelayedToggleProps = runtime.buildProps({
+  showAfter: {
+    type: Number,
+    default: 0
+  },
+  hideAfter: {
+    type: Number,
+    default: 200
+  },
+  autoClose: {
+    type: Number,
+    default: 0
+  }
+});
+const useDelayedToggle = ({
+  showAfter,
+  hideAfter,
+  autoClose,
+  open,
+  close
+}) => {
+  const { registerTimeout } = index.useTimeout();
+  const {
+    registerTimeout: registerTimeoutForAutoClose,
+    cancelTimeout: cancelTimeoutForAutoClose
+  } = index.useTimeout();
+  const onOpen = (event, delay = vue.unref(showAfter)) => {
+    registerTimeout(() => {
+      open(event);
+      const _autoClose = vue.unref(autoClose);
+      if (types.isNumber(_autoClose) && _autoClose > 0) {
+        registerTimeoutForAutoClose(() => {
+          close(event);
+        }, _autoClose);
+      }
+    }, delay);
+  };
+  const onClose = (event, delay = vue.unref(hideAfter)) => {
+    cancelTimeoutForAutoClose();
+    registerTimeout(() => {
+      close(event);
+    }, delay);
+  };
+  return {
+    onOpen,
+    onClose
+  };
+};
+
+exports.useDelayedToggle = useDelayedToggle;
+exports.useDelayedToggleProps = useDelayedToggleProps;

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

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const error = require('../../utils/error.js');
+
+const useDeprecated = ({ from, replacement, scope, version, ref, type = "API" }, condition) => {
+  vue.watch(
+    () => vue.unref(condition),
+    (val) => {
+      if (val) {
+        error.debugWarn(
+          scope,
+          `[${type}] ${from} is about to be deprecated in version ${version}, please use ${replacement} instead.
+For more detail, please visit: ${ref}
+`
+        );
+      }
+    },
+    {
+      immediate: true
+    }
+  );
+};
+
+exports.useDeprecated = useDeprecated;

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

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const style = require('../../utils/dom/style.js');
+
+const useDraggable = (targetRef, dragRef, draggable, overflow) => {
+  const transform = {
+    offsetX: 0,
+    offsetY: 0
+  };
+  const isDragging = vue.ref(false);
+  const adjustPosition = (moveX, moveY) => {
+    if (targetRef.value) {
+      const { offsetX, offsetY } = transform;
+      const targetRect = targetRef.value.getBoundingClientRect();
+      const targetLeft = targetRect.left;
+      const targetTop = targetRect.top;
+      const targetWidth = targetRect.width;
+      const targetHeight = targetRect.height;
+      const clientWidth = document.documentElement.clientWidth;
+      const clientHeight = document.documentElement.clientHeight;
+      const minLeft = -targetLeft + offsetX;
+      const minTop = -targetTop + offsetY;
+      const maxLeft = clientWidth - targetLeft - targetWidth + offsetX;
+      const maxTop = clientHeight - targetTop - (targetHeight < clientHeight ? targetHeight : 0) + offsetY;
+      if (!(overflow == null ? void 0 : overflow.value)) {
+        moveX = Math.min(Math.max(moveX, minLeft), maxLeft);
+        moveY = Math.min(Math.max(moveY, minTop), maxTop);
+      }
+      transform.offsetX = moveX;
+      transform.offsetY = moveY;
+      targetRef.value.style.transform = `translate(${style.addUnit(moveX)}, ${style.addUnit(
+        moveY
+      )})`;
+    }
+  };
+  const onMousedown = (e) => {
+    const downX = e.clientX;
+    const downY = e.clientY;
+    const { offsetX, offsetY } = transform;
+    const onMousemove = (e2) => {
+      if (!isDragging.value) {
+        isDragging.value = true;
+      }
+      const moveX = offsetX + e2.clientX - downX;
+      const moveY = offsetY + e2.clientY - downY;
+      adjustPosition(moveX, moveY);
+    };
+    const onMouseup = () => {
+      isDragging.value = false;
+      document.removeEventListener("mousemove", onMousemove);
+      document.removeEventListener("mouseup", onMouseup);
+    };
+    document.addEventListener("mousemove", onMousemove);
+    document.addEventListener("mouseup", onMouseup);
+  };
+  const onDraggable = () => {
+    if (dragRef.value && targetRef.value) {
+      dragRef.value.addEventListener("mousedown", onMousedown);
+      window.addEventListener("resize", updatePosition);
+    }
+  };
+  const offDraggable = () => {
+    if (dragRef.value && targetRef.value) {
+      dragRef.value.removeEventListener("mousedown", onMousedown);
+      window.removeEventListener("resize", updatePosition);
+    }
+  };
+  const resetPosition = () => {
+    transform.offsetX = 0;
+    transform.offsetY = 0;
+    if (targetRef.value) {
+      targetRef.value.style.transform = "";
+    }
+  };
+  const updatePosition = () => {
+    const { offsetX, offsetY } = transform;
+    adjustPosition(offsetX, offsetY);
+  };
+  vue.onMounted(() => {
+    vue.watchEffect(() => {
+      if (draggable.value) {
+        onDraggable();
+      } else {
+        offDraggable();
+      }
+    });
+  });
+  vue.onBeforeUnmount(() => {
+    offDraggable();
+  });
+  return {
+    isDragging,
+    resetPosition,
+    updatePosition
+  };
+};
+
+exports.useDraggable = useDraggable;

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

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const runtime = require('../../utils/vue/props/runtime.js');
+const shared_esmBundler = require('../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+const error = require('../../utils/error.js');
+const isEqual = require('../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEqual.js');
+
+const emptyValuesContextKey = Symbol("emptyValuesContextKey");
+const SCOPE = "use-empty-values";
+const DEFAULT_EMPTY_VALUES = ["", void 0, null];
+const DEFAULT_VALUE_ON_CLEAR = void 0;
+const useEmptyValuesProps = runtime.buildProps({
+  emptyValues: Array,
+  valueOnClear: {
+    type: runtime.definePropType([
+      String,
+      Number,
+      Boolean,
+      Function
+    ]),
+    default: void 0,
+    validator: (val) => {
+      val = shared_esmBundler.isFunction(val) ? val() : val;
+      if (shared_esmBundler.isArray(val)) {
+        return val.every((item) => !item);
+      }
+      return !val;
+    }
+  }
+});
+const useEmptyValues = (props, defaultValue) => {
+  const config = vue.getCurrentInstance() ? vue.inject(emptyValuesContextKey, vue.ref({})) : vue.ref({});
+  const emptyValues = vue.computed(
+    () => props.emptyValues || config.value.emptyValues || DEFAULT_EMPTY_VALUES
+  );
+  const valueOnClear = vue.computed(() => {
+    if (shared_esmBundler.isFunction(props.valueOnClear)) {
+      return props.valueOnClear();
+    } else if (props.valueOnClear !== void 0) {
+      return props.valueOnClear;
+    } else if (shared_esmBundler.isFunction(config.value.valueOnClear)) {
+      return config.value.valueOnClear();
+    } else if (config.value.valueOnClear !== void 0) {
+      return config.value.valueOnClear;
+    }
+    return defaultValue !== void 0 ? defaultValue : DEFAULT_VALUE_ON_CLEAR;
+  });
+  const isEmptyValue = (value) => {
+    let result = true;
+    if (shared_esmBundler.isArray(value)) {
+      result = emptyValues.value.some((emptyValue) => {
+        return isEqual.default(value, emptyValue);
+      });
+    } else {
+      result = emptyValues.value.includes(value);
+    }
+    return result;
+  };
+  if (!isEmptyValue(valueOnClear.value)) {
+    error.debugWarn(SCOPE, "value-on-clear should be a value of empty-values");
+  }
+  return {
+    emptyValues,
+    valueOnClear,
+    isEmptyValue
+  };
+};
+
+exports.DEFAULT_EMPTY_VALUES = DEFAULT_EMPTY_VALUES;
+exports.DEFAULT_VALUE_ON_CLEAR = DEFAULT_VALUE_ON_CLEAR;
+exports.SCOPE = SCOPE;
+exports.emptyValuesContextKey = emptyValuesContextKey;
+exports.useEmptyValues = useEmptyValues;
+exports.useEmptyValuesProps = useEmptyValuesProps;

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

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const event = require('../../utils/dom/event.js');
+const aria = require('../../constants/aria.js');
+const index = require('../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.js');
+
+let registeredEscapeHandlers = [];
+const cachedHandler = (event$1) => {
+  const code = event.getEventCode(event$1);
+  if (code === aria.EVENT_CODE.esc) {
+    registeredEscapeHandlers.forEach(
+      (registeredHandler) => registeredHandler(event$1)
+    );
+  }
+};
+const useEscapeKeydown = (handler) => {
+  vue.onMounted(() => {
+    if (registeredEscapeHandlers.length === 0) {
+      document.addEventListener("keydown", cachedHandler);
+    }
+    if (index.isClient)
+      registeredEscapeHandlers.push(handler);
+  });
+  vue.onBeforeUnmount(() => {
+    registeredEscapeHandlers = registeredEscapeHandlers.filter(
+      (registeredHandler) => registeredHandler !== handler
+    );
+    if (registeredEscapeHandlers.length === 0) {
+      if (index.isClient)
+        document.removeEventListener("keydown", cachedHandler);
+    }
+  });
+};
+
+exports.useEscapeKeydown = useEscapeKeydown;

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

@@ -0,0 +1,74 @@
+'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 types = require('../../utils/types.js');
+const aria = require('../../utils/dom/aria.js');
+const shared_esmBundler = require('../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+
+function useFocusController(target, {
+  disabled,
+  beforeFocus,
+  afterFocus,
+  beforeBlur,
+  afterBlur
+} = {}) {
+  const instance = vue.getCurrentInstance();
+  const { emit } = instance;
+  const wrapperRef = vue.shallowRef();
+  const isFocused = vue.ref(false);
+  const handleFocus = (event) => {
+    const cancelFocus = shared_esmBundler.isFunction(beforeFocus) ? beforeFocus(event) : false;
+    if (vue.unref(disabled) || isFocused.value || cancelFocus)
+      return;
+    isFocused.value = true;
+    emit("focus", event);
+    afterFocus == null ? void 0 : afterFocus();
+  };
+  const handleBlur = (event) => {
+    var _a;
+    const cancelBlur = shared_esmBundler.isFunction(beforeBlur) ? beforeBlur(event) : false;
+    if (vue.unref(disabled) || event.relatedTarget && ((_a = wrapperRef.value) == null ? void 0 : _a.contains(event.relatedTarget)) || cancelBlur)
+      return;
+    isFocused.value = false;
+    emit("blur", event);
+    afterBlur == null ? void 0 : afterBlur();
+  };
+  const handleClick = (event) => {
+    var _a, _b;
+    if (vue.unref(disabled) || aria.isFocusable(event.target) || ((_a = wrapperRef.value) == null ? void 0 : _a.contains(document.activeElement)) && wrapperRef.value !== document.activeElement)
+      return;
+    (_b = target.value) == null ? void 0 : _b.focus();
+  };
+  vue.watch([wrapperRef, () => vue.unref(disabled)], ([el, disabled2]) => {
+    if (!el)
+      return;
+    if (disabled2) {
+      el.removeAttribute("tabindex");
+    } else {
+      el.setAttribute("tabindex", "-1");
+    }
+  });
+  index.useEventListener(wrapperRef, "focus", handleFocus, true);
+  index.useEventListener(wrapperRef, "blur", handleBlur, true);
+  index.useEventListener(wrapperRef, "click", handleClick, true);
+  if (process.env.NODE_ENV === "test") {
+    vue.onMounted(() => {
+      const targetEl = types.isElement(target.value) ? target.value : document.querySelector("input,textarea");
+      if (targetEl) {
+        index.useEventListener(targetEl, "focus", handleFocus, true);
+        index.useEventListener(targetEl, "blur", handleBlur, true);
+      }
+    });
+  }
+  return {
+    isFocused,
+    wrapperRef,
+    handleFocus,
+    handleBlur
+  };
+}
+
+exports.useFocusController = useFocusController;

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

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+
+const FORWARD_REF_INJECTION_KEY = Symbol("elForwardRef");
+const useForwardRef = (forwardRef) => {
+  const setForwardRef = (el) => {
+    forwardRef.value = el;
+  };
+  vue.provide(FORWARD_REF_INJECTION_KEY, {
+    setForwardRef
+  });
+};
+const useForwardRefDirective = (setForwardRef) => {
+  return {
+    mounted(el) {
+      setForwardRef(el);
+    },
+    updated(el) {
+      setForwardRef(el);
+    },
+    unmounted() {
+      setForwardRef(null);
+    }
+  };
+};
+
+exports.FORWARD_REF_INJECTION_KEY = FORWARD_REF_INJECTION_KEY;
+exports.useForwardRef = useForwardRef;
+exports.useForwardRefDirective = useForwardRefDirective;

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

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const index$1 = require('../use-namespace/index.js');
+const error = require('../../utils/error.js');
+const index = require('../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.js');
+
+const defaultIdInjection = {
+  prefix: Math.floor(Math.random() * 1e4),
+  current: 0
+};
+const ID_INJECTION_KEY = Symbol("elIdInjection");
+const useIdInjection = () => {
+  return vue.getCurrentInstance() ? vue.inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
+};
+const useId = (deterministicId) => {
+  const idInjection = useIdInjection();
+  if (!index.isClient && idInjection === defaultIdInjection) {
+    error.debugWarn(
+      "IdInjection",
+      `Looks like you are using server rendering, you must provide a id provider to ensure the hydration process to be succeed
+usage: app.provide(ID_INJECTION_KEY, {
+  prefix: number,
+  current: number,
+})`
+    );
+  }
+  const namespace = index$1.useGetDerivedNamespace();
+  const idRef = index.computedEager(
+    () => vue.unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`
+  );
+  return idRef;
+};
+
+exports.ID_INJECTION_KEY = ID_INJECTION_KEY;
+exports.useId = useId;
+exports.useIdInjection = useIdInjection;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const en = require('../../locale/lang/en.js');
+const get = require('../../../../../../lodash-es@4.17.21/node_modules/lodash-es/get.js');
+
+const buildTranslator = (locale) => (path, option) => translate(path, option, vue.unref(locale));
+const translate = (path, option, locale) => get.default(locale, path, path).replace(
+  /\{(\w+)\}/g,
+  (_, key) => {
+    var _a;
+    return `${(_a = option == null ? void 0 : option[key]) != null ? _a : `{${key}}`}`;
+  }
+);
+const buildLocaleContext = (locale) => {
+  const lang = vue.computed(() => vue.unref(locale).name);
+  const localeRef = vue.isRef(locale) ? locale : vue.ref(locale);
+  return {
+    lang,
+    locale: localeRef,
+    t: buildTranslator(locale)
+  };
+};
+const localeContextKey = Symbol("localeContextKey");
+const useLocale = (localeOverrides) => {
+  const locale = vue.inject(localeContextKey, vue.ref());
+  return buildLocaleContext(vue.computed(() => locale.value || en.default));
+};
+
+exports.buildLocaleContext = buildLocaleContext;
+exports.buildTranslator = buildTranslator;
+exports.localeContextKey = localeContextKey;
+exports.translate = translate;
+exports.useLocale = useLocale;

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

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const index = require('../use-namespace/index.js');
+const error = require('../../utils/error.js');
+const style = require('../../utils/dom/style.js');
+const scroll = require('../../utils/dom/scroll.js');
+
+const useLockscreen = (trigger, options = {}) => {
+  if (!vue.isRef(trigger)) {
+    error.throwError(
+      "[useLockscreen]",
+      "You need to pass a ref param to this function"
+    );
+  }
+  const ns = options.ns || index.useNamespace("popup");
+  const hiddenCls = vue.computed(() => ns.bm("parent", "hidden"));
+  let scrollBarWidth = 0;
+  let withoutHiddenClass = false;
+  let bodyWidth = "0";
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned)
+      return;
+    cleaned = true;
+    setTimeout(() => {
+      if (typeof document === "undefined")
+        return;
+      if (withoutHiddenClass && document) {
+        document.body.style.width = bodyWidth;
+        style.removeClass(document.body, hiddenCls.value);
+      }
+    }, 200);
+  };
+  vue.watch(trigger, (val) => {
+    if (!val) {
+      cleanup();
+      return;
+    }
+    cleaned = false;
+    withoutHiddenClass = !style.hasClass(document.body, hiddenCls.value);
+    if (withoutHiddenClass) {
+      bodyWidth = document.body.style.width;
+      style.addClass(document.body, hiddenCls.value);
+    }
+    scrollBarWidth = scroll.getScrollBarWidth(ns.namespace.value);
+    const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
+    const bodyOverflowY = style.getStyle(document.body, "overflowY");
+    if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
+      document.body.style.width = `calc(100% - ${scrollBarWidth}px)`;
+    }
+  });
+  vue.onScopeDispose(() => cleanup());
+};
+
+exports.useLockscreen = useLockscreen;