@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/dialog/src/use-dialog.mjs

@@ -0,0 +1,274 @@
+import { getCurrentInstance, ref, computed, watch, nextTick, onMounted } from 'vue';
+import { DEFAULT_DIALOG_TRANSITION } from './constants.mjs';
+import { useLockscreen } from '../../../hooks/use-lockscreen/index.mjs';
+import { useZIndex } from '../../../hooks/use-z-index/index.mjs';
+import { useId } from '../../../hooks/use-id/index.mjs';
+import { useGlobalConfig } from '../../config-provider/src/hooks/use-global-config.mjs';
+import { defaultNamespace } from '../../../hooks/use-namespace/index.mjs';
+import { addUnit } from '../../../utils/dom/style.mjs';
+import { isObject, isArray, isFunction } from '../../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.mjs';
+import { debugWarn } from '../../../utils/error.mjs';
+import { UPDATE_MODEL_EVENT } from '../../../constants/event.mjs';
+import { useTimeoutFn, isClient } from '../../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs';
+
+const COMPONENT_NAME = "ElDialog";
+const useDialog = (props, targetRef) => {
+  var _a;
+  const instance = getCurrentInstance();
+  const emit = instance.emit;
+  const { nextZIndex } = useZIndex();
+  let lastPosition = "";
+  const titleId = useId();
+  const bodyId = useId();
+  const visible = ref(false);
+  const closed = ref(false);
+  const rendered = ref(false);
+  const zIndex = ref((_a = props.zIndex) != null ? _a : nextZIndex());
+  const closing = ref(false);
+  let openTimer = void 0;
+  let closeTimer = void 0;
+  const config = useGlobalConfig();
+  const namespace = computed(() => {
+    var _a2, _b;
+    return (_b = (_a2 = config.value) == null ? void 0 : _a2.namespace) != null ? _b : defaultNamespace;
+  });
+  const globalConfig = computed(() => {
+    var _a2;
+    return (_a2 = config.value) == null ? void 0 : _a2.dialog;
+  });
+  const style = computed(() => {
+    const style2 = {};
+    const varPrefix = `--${namespace.value}-dialog`;
+    if (!props.fullscreen) {
+      if (props.top) {
+        style2[`${varPrefix}-margin-top`] = props.top;
+      }
+      const width = addUnit(props.width);
+      if (width) {
+        style2[`${varPrefix}-width`] = width;
+      }
+    }
+    return style2;
+  });
+  const _draggable = computed(
+    () => {
+      var _a2, _b, _c;
+      return ((_c = (_b = props.draggable) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.draggable) != null ? _c : false) && !props.fullscreen;
+    }
+  );
+  const _alignCenter = computed(
+    () => {
+      var _a2, _b, _c;
+      return (_c = (_b = props.alignCenter) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.alignCenter) != null ? _c : false;
+    }
+  );
+  const _overflow = computed(
+    () => {
+      var _a2, _b, _c;
+      return (_c = (_b = props.overflow) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.overflow) != null ? _c : false;
+    }
+  );
+  const overlayDialogStyle = computed(() => {
+    if (_alignCenter.value) {
+      return { display: "flex" };
+    }
+    return {};
+  });
+  const transitionConfig = computed(() => {
+    var _a2, _b, _c;
+    const transition = (_c = (_b = props.transition) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.transition) != null ? _c : DEFAULT_DIALOG_TRANSITION;
+    const baseConfig = {
+      name: transition,
+      onAfterEnter: afterEnter,
+      onBeforeLeave: beforeLeave,
+      onAfterLeave: afterLeave
+    };
+    if (isObject(transition)) {
+      const config2 = { ...transition };
+      const _mergeHook = (userHook, defaultHook) => {
+        return (el) => {
+          if (isArray(userHook)) {
+            userHook.forEach((fn) => {
+              if (isFunction(fn))
+                fn(el);
+            });
+          } else if (isFunction(userHook)) {
+            userHook(el);
+          }
+          defaultHook();
+        };
+      };
+      config2.onAfterEnter = _mergeHook(config2.onAfterEnter, afterEnter);
+      config2.onBeforeLeave = _mergeHook(config2.onBeforeLeave, beforeLeave);
+      config2.onAfterLeave = _mergeHook(config2.onAfterLeave, afterLeave);
+      if (!config2.name) {
+        config2.name = DEFAULT_DIALOG_TRANSITION;
+        debugWarn(
+          COMPONENT_NAME,
+          `transition.name is missing when using object syntax, fallback to '${DEFAULT_DIALOG_TRANSITION}'`
+        );
+      }
+      return config2;
+    }
+    return baseConfig;
+  });
+  function afterEnter() {
+    emit("opened");
+  }
+  function afterLeave() {
+    emit("closed");
+    emit(UPDATE_MODEL_EVENT, false);
+    if (props.destroyOnClose) {
+      rendered.value = false;
+    }
+    closing.value = false;
+  }
+  function beforeLeave() {
+    closing.value = true;
+    emit("close");
+  }
+  function open() {
+    closeTimer == null ? void 0 : closeTimer();
+    openTimer == null ? void 0 : openTimer();
+    if (props.openDelay && props.openDelay > 0) {
+      ({ stop: openTimer } = useTimeoutFn(() => doOpen(), props.openDelay));
+    } else {
+      doOpen();
+    }
+  }
+  function close() {
+    openTimer == null ? void 0 : openTimer();
+    closeTimer == null ? void 0 : closeTimer();
+    if (props.closeDelay && props.closeDelay > 0) {
+      ({ stop: closeTimer } = useTimeoutFn(() => doClose(), props.closeDelay));
+    } else {
+      doClose();
+    }
+  }
+  function handleClose() {
+    function hide(shouldCancel) {
+      if (shouldCancel)
+        return;
+      closed.value = true;
+      visible.value = false;
+    }
+    if (props.beforeClose) {
+      props.beforeClose(hide);
+    } else {
+      close();
+    }
+  }
+  function onModalClick() {
+    if (props.closeOnClickModal) {
+      handleClose();
+    }
+  }
+  function doOpen() {
+    if (!isClient)
+      return;
+    visible.value = true;
+  }
+  function doClose() {
+    visible.value = false;
+  }
+  function onOpenAutoFocus() {
+    emit("openAutoFocus");
+  }
+  function onCloseAutoFocus() {
+    emit("closeAutoFocus");
+  }
+  function onFocusoutPrevented(event) {
+    var _a2;
+    if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) === "pointer") {
+      event.preventDefault();
+    }
+  }
+  if (props.lockScroll) {
+    useLockscreen(visible);
+  }
+  function onCloseRequested() {
+    if (props.closeOnPressEscape) {
+      handleClose();
+    }
+  }
+  watch(
+    () => props.zIndex,
+    () => {
+      var _a2;
+      zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
+    }
+  );
+  watch(
+    () => props.modelValue,
+    (val) => {
+      var _a2;
+      if (val) {
+        closed.value = false;
+        closing.value = false;
+        open();
+        rendered.value = true;
+        zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
+        nextTick(() => {
+          emit("open");
+          if (targetRef.value) {
+            targetRef.value.parentElement.scrollTop = 0;
+            targetRef.value.parentElement.scrollLeft = 0;
+            targetRef.value.scrollTop = 0;
+          }
+        });
+      } else {
+        if (visible.value) {
+          close();
+        }
+      }
+    }
+  );
+  watch(
+    () => props.fullscreen,
+    (val) => {
+      if (!targetRef.value)
+        return;
+      if (val) {
+        lastPosition = targetRef.value.style.transform;
+        targetRef.value.style.transform = "";
+      } else {
+        targetRef.value.style.transform = lastPosition;
+      }
+    }
+  );
+  onMounted(() => {
+    if (props.modelValue) {
+      visible.value = true;
+      rendered.value = true;
+      open();
+    }
+  });
+  return {
+    afterEnter,
+    afterLeave,
+    beforeLeave,
+    handleClose,
+    onModalClick,
+    close,
+    doClose,
+    onOpenAutoFocus,
+    onCloseAutoFocus,
+    onCloseRequested,
+    onFocusoutPrevented,
+    titleId,
+    bodyId,
+    closed,
+    style,
+    overlayDialogStyle,
+    rendered,
+    visible,
+    zIndex,
+    transitionConfig,
+    _draggable,
+    _alignCenter,
+    _overflow,
+    closing
+  };
+};
+
+export { useDialog };

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

@@ -0,0 +1,278 @@
+import { defineComponent, renderSlot, ref, provide, watch, unref, onMounted, onBeforeUnmount, nextTick } from 'vue';
+import { useFocusReason, tryFocus, createFocusOutPreventedEvent, getEdges, focusableStack, focusFirstDescendant, obtainAllFocusableElements, isFocusCausedByUserEvent } from './utils.mjs';
+import { ON_TRAP_FOCUS_EVT, ON_RELEASE_FOCUS_EVT, FOCUS_TRAP_INJECTION_KEY, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_AFTER_RELEASED } from './tokens.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { useEscapeKeydown } from '../../../hooks/use-escape-keydown/index.mjs';
+import { getEventCode } from '../../../utils/dom/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 _sfc_main = defineComponent({
+  name: "ElFocusTrap",
+  inheritAttrs: false,
+  props: {
+    loop: Boolean,
+    trapped: Boolean,
+    focusTrapEl: Object,
+    focusStartEl: {
+      type: [Object, String],
+      default: "first"
+    }
+  },
+  emits: [
+    ON_TRAP_FOCUS_EVT,
+    ON_RELEASE_FOCUS_EVT,
+    "focusin",
+    "focusout",
+    "focusout-prevented",
+    "release-requested"
+  ],
+  setup(props, { emit }) {
+    const forwardRef = ref();
+    let lastFocusBeforeTrapped;
+    let lastFocusAfterTrapped;
+    const { focusReason } = useFocusReason();
+    useEscapeKeydown((event) => {
+      if (props.trapped && !focusLayer.paused) {
+        emit("release-requested", event);
+      }
+    });
+    const focusLayer = {
+      paused: false,
+      pause() {
+        this.paused = true;
+      },
+      resume() {
+        this.paused = false;
+      }
+    };
+    const onKeydown = (e) => {
+      if (!props.loop && !props.trapped)
+        return;
+      if (focusLayer.paused)
+        return;
+      const { altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
+      const { loop } = props;
+      const code = getEventCode(e);
+      const isTabbing = code === EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
+      const currentFocusingEl = document.activeElement;
+      if (isTabbing && currentFocusingEl) {
+        const container = currentTarget;
+        const [first, last] = getEdges(container);
+        const isTabbable = first && last;
+        if (!isTabbable) {
+          if (currentFocusingEl === container) {
+            const focusoutPreventedEvent = createFocusOutPreventedEvent({
+              focusReason: focusReason.value
+            });
+            emit("focusout-prevented", focusoutPreventedEvent);
+            if (!focusoutPreventedEvent.defaultPrevented) {
+              e.preventDefault();
+            }
+          }
+        } else {
+          if (!shiftKey && currentFocusingEl === last) {
+            const focusoutPreventedEvent = createFocusOutPreventedEvent({
+              focusReason: focusReason.value
+            });
+            emit("focusout-prevented", focusoutPreventedEvent);
+            if (!focusoutPreventedEvent.defaultPrevented) {
+              e.preventDefault();
+              if (loop)
+                tryFocus(first, true);
+            }
+          } else if (shiftKey && [first, container].includes(currentFocusingEl)) {
+            const focusoutPreventedEvent = createFocusOutPreventedEvent({
+              focusReason: focusReason.value
+            });
+            emit("focusout-prevented", focusoutPreventedEvent);
+            if (!focusoutPreventedEvent.defaultPrevented) {
+              e.preventDefault();
+              if (loop)
+                tryFocus(last, true);
+            }
+          }
+        }
+      }
+    };
+    provide(FOCUS_TRAP_INJECTION_KEY, {
+      focusTrapRef: forwardRef,
+      onKeydown
+    });
+    watch(
+      () => props.focusTrapEl,
+      (focusTrapEl) => {
+        if (focusTrapEl) {
+          forwardRef.value = focusTrapEl;
+        }
+      },
+      { immediate: true }
+    );
+    watch([forwardRef], ([forwardRef2], [oldForwardRef]) => {
+      if (forwardRef2) {
+        forwardRef2.addEventListener("keydown", onKeydown);
+        forwardRef2.addEventListener("focusin", onFocusIn);
+        forwardRef2.addEventListener("focusout", onFocusOut);
+      }
+      if (oldForwardRef) {
+        oldForwardRef.removeEventListener("keydown", onKeydown);
+        oldForwardRef.removeEventListener("focusin", onFocusIn);
+        oldForwardRef.removeEventListener("focusout", onFocusOut);
+      }
+    });
+    const trapOnFocus = (e) => {
+      emit(ON_TRAP_FOCUS_EVT, e);
+    };
+    const releaseOnFocus = (e) => emit(ON_RELEASE_FOCUS_EVT, e);
+    const onFocusIn = (e) => {
+      const trapContainer = unref(forwardRef);
+      if (!trapContainer)
+        return;
+      const target = e.target;
+      const relatedTarget = e.relatedTarget;
+      const isFocusedInTrap = target && trapContainer.contains(target);
+      if (!props.trapped) {
+        const isPrevFocusedInTrap = relatedTarget && trapContainer.contains(relatedTarget);
+        if (!isPrevFocusedInTrap) {
+          lastFocusBeforeTrapped = relatedTarget;
+        }
+      }
+      if (isFocusedInTrap)
+        emit("focusin", e);
+      if (focusLayer.paused)
+        return;
+      if (props.trapped) {
+        if (isFocusedInTrap) {
+          lastFocusAfterTrapped = target;
+        } else {
+          tryFocus(lastFocusAfterTrapped, true);
+        }
+      }
+    };
+    const onFocusOut = (e) => {
+      const trapContainer = unref(forwardRef);
+      if (focusLayer.paused || !trapContainer)
+        return;
+      if (props.trapped) {
+        const relatedTarget = e.relatedTarget;
+        if (!isNil(relatedTarget) && !trapContainer.contains(relatedTarget)) {
+          setTimeout(() => {
+            if (!focusLayer.paused && props.trapped) {
+              const focusoutPreventedEvent = createFocusOutPreventedEvent({
+                focusReason: focusReason.value
+              });
+              emit("focusout-prevented", focusoutPreventedEvent);
+              if (!focusoutPreventedEvent.defaultPrevented) {
+                tryFocus(lastFocusAfterTrapped, true);
+              }
+            }
+          }, 0);
+        }
+      } else {
+        const target = e.target;
+        const isFocusedInTrap = target && trapContainer.contains(target);
+        if (!isFocusedInTrap)
+          emit("focusout", e);
+      }
+    };
+    async function startTrap() {
+      await nextTick();
+      const trapContainer = unref(forwardRef);
+      if (trapContainer) {
+        focusableStack.push(focusLayer);
+        const prevFocusedElement = trapContainer.contains(
+          document.activeElement
+        ) ? lastFocusBeforeTrapped : document.activeElement;
+        lastFocusBeforeTrapped = prevFocusedElement;
+        const isPrevFocusContained = trapContainer.contains(prevFocusedElement);
+        if (!isPrevFocusContained) {
+          const focusEvent = new Event(
+            FOCUS_AFTER_TRAPPED,
+            FOCUS_AFTER_TRAPPED_OPTS
+          );
+          trapContainer.addEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
+          trapContainer.dispatchEvent(focusEvent);
+          if (!focusEvent.defaultPrevented) {
+            nextTick(() => {
+              let focusStartEl = props.focusStartEl;
+              if (!isString(focusStartEl)) {
+                tryFocus(focusStartEl);
+                if (document.activeElement !== focusStartEl) {
+                  focusStartEl = "first";
+                }
+              }
+              if (focusStartEl === "first") {
+                focusFirstDescendant(
+                  obtainAllFocusableElements(trapContainer),
+                  true
+                );
+              }
+              if (document.activeElement === prevFocusedElement || focusStartEl === "container") {
+                tryFocus(trapContainer);
+              }
+            });
+          }
+        }
+      }
+    }
+    function stopTrap() {
+      const trapContainer = unref(forwardRef);
+      if (trapContainer) {
+        trapContainer.removeEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
+        const releasedEvent = new CustomEvent(FOCUS_AFTER_RELEASED, {
+          ...FOCUS_AFTER_TRAPPED_OPTS,
+          detail: {
+            focusReason: focusReason.value
+          }
+        });
+        trapContainer.addEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
+        trapContainer.dispatchEvent(releasedEvent);
+        if (!releasedEvent.defaultPrevented && (focusReason.value == "keyboard" || !isFocusCausedByUserEvent() || trapContainer.contains(document.activeElement))) {
+          tryFocus(lastFocusBeforeTrapped != null ? lastFocusBeforeTrapped : document.body);
+        }
+        trapContainer.removeEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
+        focusableStack.remove(focusLayer);
+        lastFocusBeforeTrapped = null;
+        lastFocusAfterTrapped = null;
+      }
+    }
+    onMounted(() => {
+      if (props.trapped) {
+        startTrap();
+      }
+      watch(
+        () => props.trapped,
+        (trapped) => {
+          if (trapped) {
+            startTrap();
+          } else {
+            stopTrap();
+          }
+        }
+      );
+    });
+    onBeforeUnmount(() => {
+      if (props.trapped) {
+        stopTrap();
+      }
+      if (forwardRef.value) {
+        forwardRef.value.removeEventListener("keydown", onKeydown);
+        forwardRef.value.removeEventListener("focusin", onFocusIn);
+        forwardRef.value.removeEventListener("focusout", onFocusOut);
+        forwardRef.value = void 0;
+      }
+      lastFocusBeforeTrapped = null;
+      lastFocusAfterTrapped = null;
+    });
+    return {
+      onKeydown
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return renderSlot(_ctx.$slots, "default", { handleKeydown: _ctx.onKeydown });
+}
+var ElFocusTrap = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/focus-trap/src/focus-trap.vue"]]);
+
+export { ElFocusTrap as default };

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

@@ -0,0 +1,16 @@
+const FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
+const FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
+const FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
+const FOCUS_AFTER_TRAPPED_OPTS = {
+  cancelable: true,
+  bubbles: false
+};
+const FOCUSOUT_PREVENTED_OPTS = {
+  cancelable: true,
+  bubbles: false
+};
+const ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
+const ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
+const FOCUS_TRAP_INJECTION_KEY = Symbol("elFocusTrap");
+
+export { FOCUSOUT_PREVENTED, FOCUSOUT_PREVENTED_OPTS, FOCUS_AFTER_RELEASED, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_TRAP_INJECTION_KEY, ON_RELEASE_FOCUS_EVT, ON_TRAP_FOCUS_EVT };

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

@@ -0,0 +1,140 @@
+import { onMounted, onBeforeUnmount, ref } from 'vue';
+import { FOCUSOUT_PREVENTED, FOCUSOUT_PREVENTED_OPTS } from './tokens.mjs';
+import { focusElement } from '../../../utils/dom/aria.mjs';
+
+const focusReason = ref();
+const lastUserFocusTimestamp = ref(0);
+const lastAutomatedFocusTimestamp = ref(0);
+let focusReasonUserCount = 0;
+const obtainAllFocusableElements = (element) => {
+  const nodes = [];
+  const walker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (node) => {
+      const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+      if (node.disabled || node.hidden || isHiddenInput)
+        return NodeFilter.FILTER_SKIP;
+      return node.tabIndex >= 0 || node === document.activeElement ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  while (walker.nextNode())
+    nodes.push(walker.currentNode);
+  return nodes;
+};
+const getVisibleElement = (elements, container) => {
+  for (const element of elements) {
+    if (!isHidden(element, container))
+      return element;
+  }
+};
+const isHidden = (element, container) => {
+  if (process.env.NODE_ENV === "test")
+    return false;
+  if (getComputedStyle(element).visibility === "hidden")
+    return true;
+  while (element) {
+    if (container && element === container)
+      return false;
+    if (getComputedStyle(element).display === "none")
+      return true;
+    element = element.parentElement;
+  }
+  return false;
+};
+const getEdges = (container) => {
+  const focusable = obtainAllFocusableElements(container);
+  const first = getVisibleElement(focusable, container);
+  const last = getVisibleElement(focusable.reverse(), container);
+  return [first, last];
+};
+const isSelectable = (element) => {
+  return element instanceof HTMLInputElement && "select" in element;
+};
+const tryFocus = (element, shouldSelect) => {
+  if (element) {
+    const prevFocusedElement = document.activeElement;
+    focusElement(element, { preventScroll: true });
+    lastAutomatedFocusTimestamp.value = window.performance.now();
+    if (element !== prevFocusedElement && isSelectable(element) && shouldSelect) {
+      element.select();
+    }
+  }
+};
+function removeFromStack(list, item) {
+  const copy = [...list];
+  const idx = list.indexOf(item);
+  if (idx !== -1) {
+    copy.splice(idx, 1);
+  }
+  return copy;
+}
+const createFocusableStack = () => {
+  let stack = [];
+  const push = (layer) => {
+    const currentLayer = stack[0];
+    if (currentLayer && layer !== currentLayer) {
+      currentLayer.pause();
+    }
+    stack = removeFromStack(stack, layer);
+    stack.unshift(layer);
+  };
+  const remove = (layer) => {
+    var _a, _b;
+    stack = removeFromStack(stack, layer);
+    (_b = (_a = stack[0]) == null ? void 0 : _a.resume) == null ? void 0 : _b.call(_a);
+  };
+  return {
+    push,
+    remove
+  };
+};
+const focusFirstDescendant = (elements, shouldSelect = false) => {
+  const prevFocusedElement = document.activeElement;
+  for (const element of elements) {
+    tryFocus(element, shouldSelect);
+    if (document.activeElement !== prevFocusedElement)
+      return;
+  }
+};
+const focusableStack = createFocusableStack();
+const isFocusCausedByUserEvent = () => {
+  return lastUserFocusTimestamp.value > lastAutomatedFocusTimestamp.value;
+};
+const notifyFocusReasonPointer = () => {
+  focusReason.value = "pointer";
+  lastUserFocusTimestamp.value = window.performance.now();
+};
+const notifyFocusReasonKeydown = () => {
+  focusReason.value = "keyboard";
+  lastUserFocusTimestamp.value = window.performance.now();
+};
+const useFocusReason = () => {
+  onMounted(() => {
+    if (focusReasonUserCount === 0) {
+      document.addEventListener("mousedown", notifyFocusReasonPointer);
+      document.addEventListener("touchstart", notifyFocusReasonPointer);
+      document.addEventListener("keydown", notifyFocusReasonKeydown);
+    }
+    focusReasonUserCount++;
+  });
+  onBeforeUnmount(() => {
+    focusReasonUserCount--;
+    if (focusReasonUserCount <= 0) {
+      document.removeEventListener("mousedown", notifyFocusReasonPointer);
+      document.removeEventListener("touchstart", notifyFocusReasonPointer);
+      document.removeEventListener("keydown", notifyFocusReasonKeydown);
+    }
+  });
+  return {
+    focusReason,
+    lastUserFocusTimestamp,
+    lastAutomatedFocusTimestamp
+  };
+};
+const createFocusOutPreventedEvent = (detail) => {
+  return new CustomEvent(FOCUSOUT_PREVENTED, {
+    ...FOCUSOUT_PREVENTED_OPTS,
+    detail
+  });
+};
+
+export { createFocusOutPreventedEvent, focusFirstDescendant, focusableStack, getEdges, getVisibleElement, isFocusCausedByUserEvent, isHidden, obtainAllFocusableElements, tryFocus, useFocusReason };