@eightshift/ui-components 0.0.1

package/dist/focusSafely-C3K8zAKj.js

@@ -0,0 +1,743 @@
+import { g as $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c, f as $8ae05eaa5c114e9c$export$7f54fc3180508a52, o as $b5e257d569688ac6$export$535bd6ca7f90a273 } from "./utils-BsiH7-5Y.js";
+import { useState, useRef, useEffect, useCallback, useMemo } from "react";
+const $431fbd86ca7dc216$export$b204af158042fbac = (el) => {
+  var _el_ownerDocument;
+  return (_el_ownerDocument = el === null || el === void 0 ? void 0 : el.ownerDocument) !== null && _el_ownerDocument !== void 0 ? _el_ownerDocument : document;
+};
+const $431fbd86ca7dc216$export$f21a1ffae260145a = (el) => {
+  if (el && "window" in el && el.window === el)
+    return el;
+  const doc = $431fbd86ca7dc216$export$b204af158042fbac(el);
+  return doc.defaultView || window;
+};
+function $7215afc6de606d6b$export$de79e2c695e052f3(element) {
+  if ($7215afc6de606d6b$var$supportsPreventScroll())
+    element.focus({
+      preventScroll: true
+    });
+  else {
+    let scrollableElements = $7215afc6de606d6b$var$getScrollableElements(element);
+    element.focus();
+    $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements);
+  }
+}
+let $7215afc6de606d6b$var$supportsPreventScrollCached = null;
+function $7215afc6de606d6b$var$supportsPreventScroll() {
+  if ($7215afc6de606d6b$var$supportsPreventScrollCached == null) {
+    $7215afc6de606d6b$var$supportsPreventScrollCached = false;
+    try {
+      let focusElem = document.createElement("div");
+      focusElem.focus({
+        get preventScroll() {
+          $7215afc6de606d6b$var$supportsPreventScrollCached = true;
+          return true;
+        }
+      });
+    } catch (e) {
+    }
+  }
+  return $7215afc6de606d6b$var$supportsPreventScrollCached;
+}
+function $7215afc6de606d6b$var$getScrollableElements(element) {
+  let parent = element.parentNode;
+  let scrollableElements = [];
+  let rootScrollingElement = document.scrollingElement || document.documentElement;
+  while (parent instanceof HTMLElement && parent !== rootScrollingElement) {
+    if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth)
+      scrollableElements.push({
+        element: parent,
+        scrollTop: parent.scrollTop,
+        scrollLeft: parent.scrollLeft
+      });
+    parent = parent.parentNode;
+  }
+  if (rootScrollingElement instanceof HTMLElement)
+    scrollableElements.push({
+      element: rootScrollingElement,
+      scrollTop: rootScrollingElement.scrollTop,
+      scrollLeft: rootScrollingElement.scrollLeft
+    });
+  return scrollableElements;
+}
+function $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements) {
+  for (let { element, scrollTop, scrollLeft } of scrollableElements) {
+    element.scrollTop = scrollTop;
+    element.scrollLeft = scrollLeft;
+  }
+}
+function $c87311424ea30a05$var$testUserAgent(re) {
+  var _window_navigator_userAgentData;
+  if (typeof window === "undefined" || window.navigator == null)
+    return false;
+  return ((_window_navigator_userAgentData = window.navigator["userAgentData"]) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.brands.some((brand) => re.test(brand.brand))) || re.test(window.navigator.userAgent);
+}
+function $c87311424ea30a05$var$testPlatform(re) {
+  var _window_navigator_userAgentData;
+  return typeof window !== "undefined" && window.navigator != null ? re.test(((_window_navigator_userAgentData = window.navigator["userAgentData"]) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.platform) || window.navigator.platform) : false;
+}
+function $c87311424ea30a05$export$9ac100e40613ea10() {
+  return $c87311424ea30a05$var$testPlatform(/^Mac/i);
+}
+function $c87311424ea30a05$export$186c6964ca17d99() {
+  return $c87311424ea30a05$var$testPlatform(/^iPhone/i);
+}
+function $c87311424ea30a05$export$7bef049ce92e4224() {
+  return $c87311424ea30a05$var$testPlatform(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+  $c87311424ea30a05$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;
+}
+function $c87311424ea30a05$export$fedb369cb70207f1() {
+  return $c87311424ea30a05$export$186c6964ca17d99() || $c87311424ea30a05$export$7bef049ce92e4224();
+}
+function $c87311424ea30a05$export$e1865c3bedcd822b() {
+  return $c87311424ea30a05$export$9ac100e40613ea10() || $c87311424ea30a05$export$fedb369cb70207f1();
+}
+function $c87311424ea30a05$export$78551043582a6a98() {
+  return $c87311424ea30a05$var$testUserAgent(/AppleWebKit/i) && !$c87311424ea30a05$export$6446a186d09e379e();
+}
+function $c87311424ea30a05$export$6446a186d09e379e() {
+  return $c87311424ea30a05$var$testUserAgent(/Chrome/i);
+}
+function $c87311424ea30a05$export$a11b0059900ceec8() {
+  return $c87311424ea30a05$var$testUserAgent(/Android/i);
+}
+function $c87311424ea30a05$export$b7d78993b74f766d() {
+  return $c87311424ea30a05$var$testUserAgent(/Firefox/i);
+}
+let $bbed8b41f857bcc0$var$transitionsByElement = /* @__PURE__ */ new Map();
+let $bbed8b41f857bcc0$var$transitionCallbacks = /* @__PURE__ */ new Set();
+function $bbed8b41f857bcc0$var$setupGlobalEvents() {
+  if (typeof window === "undefined")
+    return;
+  function isTransitionEvent(event) {
+    return "propertyName" in event;
+  }
+  let onTransitionStart = (e) => {
+    if (!isTransitionEvent(e) || !e.target)
+      return;
+    let transitions = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+    if (!transitions) {
+      transitions = /* @__PURE__ */ new Set();
+      $bbed8b41f857bcc0$var$transitionsByElement.set(e.target, transitions);
+      e.target.addEventListener("transitioncancel", onTransitionEnd, {
+        once: true
+      });
+    }
+    transitions.add(e.propertyName);
+  };
+  let onTransitionEnd = (e) => {
+    if (!isTransitionEvent(e) || !e.target)
+      return;
+    let properties = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+    if (!properties)
+      return;
+    properties.delete(e.propertyName);
+    if (properties.size === 0) {
+      e.target.removeEventListener("transitioncancel", onTransitionEnd);
+      $bbed8b41f857bcc0$var$transitionsByElement.delete(e.target);
+    }
+    if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) {
+      for (let cb of $bbed8b41f857bcc0$var$transitionCallbacks)
+        cb();
+      $bbed8b41f857bcc0$var$transitionCallbacks.clear();
+    }
+  };
+  document.body.addEventListener("transitionrun", onTransitionStart);
+  document.body.addEventListener("transitionend", onTransitionEnd);
+}
+if (typeof document !== "undefined") {
+  if (document.readyState !== "loading")
+    $bbed8b41f857bcc0$var$setupGlobalEvents();
+  else
+    document.addEventListener("DOMContentLoaded", $bbed8b41f857bcc0$var$setupGlobalEvents);
+}
+function $bbed8b41f857bcc0$export$24490316f764c430(fn) {
+  requestAnimationFrame(() => {
+    if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0)
+      fn();
+    else
+      $bbed8b41f857bcc0$var$transitionCallbacks.add(fn);
+  });
+}
+function $e7801be82b4b2a53$export$4debdb1a3f0fa79e(context, ref) {
+  $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+    if (context && context.ref && ref) {
+      context.ref.current = ref.current;
+      return () => {
+        if (context.ref)
+          context.ref.current = null;
+      };
+    }
+  });
+}
+function $6a7db85432448f7f$export$60278871457622de(event) {
+  if (event.mozInputSource === 0 && event.isTrusted)
+    return true;
+  if ($c87311424ea30a05$export$a11b0059900ceec8() && event.pointerType)
+    return event.type === "click" && event.buttons === 1;
+  return event.detail === 0 && !event.pointerType;
+}
+function $6a7db85432448f7f$export$29bf1b5f2c56cf63(event) {
+  return !$c87311424ea30a05$export$a11b0059900ceec8() && event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse";
+}
+function $458b0a5536c1a7cf$export$40bfa8c7b0832715(value, defaultValue, onChange) {
+  let [stateValue, setStateValue] = useState(value || defaultValue);
+  let isControlledRef = useRef(value !== void 0);
+  let isControlled = value !== void 0;
+  useEffect(() => {
+    let wasControlled = isControlledRef.current;
+    if (wasControlled !== isControlled)
+      console.warn(`WARN: A component changed from ${wasControlled ? "controlled" : "uncontrolled"} to ${isControlled ? "controlled" : "uncontrolled"}.`);
+    isControlledRef.current = isControlled;
+  }, [
+    isControlled
+  ]);
+  let currentValue = isControlled ? value : stateValue;
+  let setValue = useCallback((value2, ...args) => {
+    let onChangeCaller = (value3, ...onChangeArgs) => {
+      if (onChange) {
+        if (!Object.is(currentValue, value3))
+          onChange(value3, ...onChangeArgs);
+      }
+      if (!isControlled)
+        currentValue = value3;
+    };
+    if (typeof value2 === "function") {
+      console.warn("We can not support a function callback. See Github Issues for details https://github.com/adobe/react-spectrum/issues/2320");
+      let updateFunction = (oldValue, ...functionArgs) => {
+        let interceptedValue = value2(isControlled ? currentValue : oldValue, ...functionArgs);
+        onChangeCaller(interceptedValue, ...args);
+        if (!isControlled)
+          return interceptedValue;
+        return oldValue;
+      };
+      setStateValue(updateFunction);
+    } else {
+      if (!isControlled)
+        setStateValue(value2);
+      onChangeCaller(value2, ...args);
+    }
+  }, [
+    isControlled,
+    currentValue,
+    onChange
+  ]);
+  return [
+    currentValue,
+    setValue
+  ];
+}
+class $8a9cb279dc87e130$export$905e7fc544a71f36 {
+  isDefaultPrevented() {
+    return this.nativeEvent.defaultPrevented;
+  }
+  preventDefault() {
+    this.defaultPrevented = true;
+    this.nativeEvent.preventDefault();
+  }
+  stopPropagation() {
+    this.nativeEvent.stopPropagation();
+    this.isPropagationStopped = () => true;
+  }
+  isPropagationStopped() {
+    return false;
+  }
+  persist() {
+  }
+  constructor(type, nativeEvent) {
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEvent.target;
+    this.currentTarget = nativeEvent.currentTarget;
+    this.relatedTarget = nativeEvent.relatedTarget;
+    this.bubbles = nativeEvent.bubbles;
+    this.cancelable = nativeEvent.cancelable;
+    this.defaultPrevented = nativeEvent.defaultPrevented;
+    this.eventPhase = nativeEvent.eventPhase;
+    this.isTrusted = nativeEvent.isTrusted;
+    this.timeStamp = nativeEvent.timeStamp;
+    this.type = type;
+  }
+}
+function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
+  let stateRef = useRef({
+    isFocused: false,
+    observer: null
+  });
+  $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+    const state = stateRef.current;
+    return () => {
+      if (state.observer) {
+        state.observer.disconnect();
+        state.observer = null;
+      }
+    };
+  }, []);
+  let dispatchBlur = $8ae05eaa5c114e9c$export$7f54fc3180508a52((e) => {
+    onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
+  });
+  return useCallback((e) => {
+    if (e.target instanceof HTMLButtonElement || e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLSelectElement) {
+      stateRef.current.isFocused = true;
+      let target = e.target;
+      let onBlurHandler = (e2) => {
+        stateRef.current.isFocused = false;
+        if (target.disabled)
+          dispatchBlur(new $8a9cb279dc87e130$export$905e7fc544a71f36("blur", e2));
+        if (stateRef.current.observer) {
+          stateRef.current.observer.disconnect();
+          stateRef.current.observer = null;
+        }
+      };
+      target.addEventListener("focusout", onBlurHandler, {
+        once: true
+      });
+      stateRef.current.observer = new MutationObserver(() => {
+        if (stateRef.current.isFocused && target.disabled) {
+          var _stateRef_current_observer;
+          (_stateRef_current_observer = stateRef.current.observer) === null || _stateRef_current_observer === void 0 ? void 0 : _stateRef_current_observer.disconnect();
+          let relatedTargetEl = target === document.activeElement ? null : document.activeElement;
+          target.dispatchEvent(new FocusEvent("blur", {
+            relatedTarget: relatedTargetEl
+          }));
+          target.dispatchEvent(new FocusEvent("focusout", {
+            bubbles: true,
+            relatedTarget: relatedTargetEl
+          }));
+        }
+      });
+      stateRef.current.observer.observe(target, {
+        attributes: true,
+        attributeFilter: [
+          "disabled"
+        ]
+      });
+    }
+  }, [
+    dispatchBlur
+  ]);
+}
+function $a1ea59d68270f0dd$export$f8168d8dd8fd66e6(props) {
+  let { isDisabled, onFocus: onFocusProp, onBlur: onBlurProp, onFocusChange } = props;
+  const onBlur = useCallback((e) => {
+    if (e.target === e.currentTarget) {
+      if (onBlurProp)
+        onBlurProp(e);
+      if (onFocusChange)
+        onFocusChange(false);
+      return true;
+    }
+  }, [
+    onBlurProp,
+    onFocusChange
+  ]);
+  const onSyntheticFocus = $8a9cb279dc87e130$export$715c682d09d639cc(onBlur);
+  const onFocus = useCallback((e) => {
+    const ownerDocument = $431fbd86ca7dc216$export$b204af158042fbac(e.target);
+    if (e.target === e.currentTarget && ownerDocument.activeElement === e.target) {
+      if (onFocusProp)
+        onFocusProp(e);
+      if (onFocusChange)
+        onFocusChange(true);
+      onSyntheticFocus(e);
+    }
+  }, [
+    onFocusChange,
+    onFocusProp,
+    onSyntheticFocus
+  ]);
+  return {
+    focusProps: {
+      onFocus: !isDisabled && (onFocusProp || onFocusChange || onBlurProp) ? onFocus : void 0,
+      onBlur: !isDisabled && (onBlurProp || onFocusChange) ? onBlur : void 0
+    }
+  };
+}
+let $507fabe10e71c6fb$var$currentModality = null;
+let $507fabe10e71c6fb$var$changeHandlers = /* @__PURE__ */ new Set();
+let $507fabe10e71c6fb$export$d90243b58daecda7 = /* @__PURE__ */ new Map();
+let $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+let $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
+const $507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS = {
+  Tab: true,
+  Escape: true
+};
+function $507fabe10e71c6fb$var$triggerChangeHandlers(modality, e) {
+  for (let handler of $507fabe10e71c6fb$var$changeHandlers)
+    handler(modality, e);
+}
+function $507fabe10e71c6fb$var$isValidKey(e) {
+  return !(e.metaKey || !$c87311424ea30a05$export$9ac100e40613ea10() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+function $507fabe10e71c6fb$var$handleKeyboardEvent(e) {
+  $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+  if ($507fabe10e71c6fb$var$isValidKey(e)) {
+    $507fabe10e71c6fb$var$currentModality = "keyboard";
+    $507fabe10e71c6fb$var$triggerChangeHandlers("keyboard", e);
+  }
+}
+function $507fabe10e71c6fb$var$handlePointerEvent(e) {
+  $507fabe10e71c6fb$var$currentModality = "pointer";
+  if (e.type === "mousedown" || e.type === "pointerdown") {
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+    $507fabe10e71c6fb$var$triggerChangeHandlers("pointer", e);
+  }
+}
+function $507fabe10e71c6fb$var$handleClickEvent(e) {
+  if ($6a7db85432448f7f$export$60278871457622de(e)) {
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+    $507fabe10e71c6fb$var$currentModality = "virtual";
+  }
+}
+function $507fabe10e71c6fb$var$handleFocusEvent(e) {
+  if (e.target === window || e.target === document)
+    return;
+  if (!$507fabe10e71c6fb$var$hasEventBeforeFocus && !$507fabe10e71c6fb$var$hasBlurredWindowRecently) {
+    $507fabe10e71c6fb$var$currentModality = "virtual";
+    $507fabe10e71c6fb$var$triggerChangeHandlers("virtual", e);
+  }
+  $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+  $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
+}
+function $507fabe10e71c6fb$var$handleWindowBlur() {
+  $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+  $507fabe10e71c6fb$var$hasBlurredWindowRecently = true;
+}
+function $507fabe10e71c6fb$var$setupGlobalFocusEvents(element) {
+  if (typeof window === "undefined" || $507fabe10e71c6fb$export$d90243b58daecda7.get($431fbd86ca7dc216$export$f21a1ffae260145a(element)))
+    return;
+  const windowObject = $431fbd86ca7dc216$export$f21a1ffae260145a(element);
+  const documentObject = $431fbd86ca7dc216$export$b204af158042fbac(element);
+  let focus = windowObject.HTMLElement.prototype.focus;
+  windowObject.HTMLElement.prototype.focus = function() {
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+    focus.apply(this, arguments);
+  };
+  documentObject.addEventListener("keydown", $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+  documentObject.addEventListener("keyup", $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+  documentObject.addEventListener("click", $507fabe10e71c6fb$var$handleClickEvent, true);
+  windowObject.addEventListener("focus", $507fabe10e71c6fb$var$handleFocusEvent, true);
+  windowObject.addEventListener("blur", $507fabe10e71c6fb$var$handleWindowBlur, false);
+  if (typeof PointerEvent !== "undefined") {
+    documentObject.addEventListener("pointerdown", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.addEventListener("pointermove", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.addEventListener("pointerup", $507fabe10e71c6fb$var$handlePointerEvent, true);
+  } else {
+    documentObject.addEventListener("mousedown", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.addEventListener("mousemove", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.addEventListener("mouseup", $507fabe10e71c6fb$var$handlePointerEvent, true);
+  }
+  windowObject.addEventListener("beforeunload", () => {
+    $507fabe10e71c6fb$var$tearDownWindowFocusTracking(element);
+  }, {
+    once: true
+  });
+  $507fabe10e71c6fb$export$d90243b58daecda7.set(windowObject, {
+    focus
+  });
+}
+const $507fabe10e71c6fb$var$tearDownWindowFocusTracking = (element, loadListener) => {
+  const windowObject = $431fbd86ca7dc216$export$f21a1ffae260145a(element);
+  const documentObject = $431fbd86ca7dc216$export$b204af158042fbac(element);
+  if (loadListener)
+    documentObject.removeEventListener("DOMContentLoaded", loadListener);
+  if (!$507fabe10e71c6fb$export$d90243b58daecda7.has(windowObject))
+    return;
+  windowObject.HTMLElement.prototype.focus = $507fabe10e71c6fb$export$d90243b58daecda7.get(windowObject).focus;
+  documentObject.removeEventListener("keydown", $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+  documentObject.removeEventListener("keyup", $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+  documentObject.removeEventListener("click", $507fabe10e71c6fb$var$handleClickEvent, true);
+  windowObject.removeEventListener("focus", $507fabe10e71c6fb$var$handleFocusEvent, true);
+  windowObject.removeEventListener("blur", $507fabe10e71c6fb$var$handleWindowBlur, false);
+  if (typeof PointerEvent !== "undefined") {
+    documentObject.removeEventListener("pointerdown", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.removeEventListener("pointermove", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.removeEventListener("pointerup", $507fabe10e71c6fb$var$handlePointerEvent, true);
+  } else {
+    documentObject.removeEventListener("mousedown", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.removeEventListener("mousemove", $507fabe10e71c6fb$var$handlePointerEvent, true);
+    documentObject.removeEventListener("mouseup", $507fabe10e71c6fb$var$handlePointerEvent, true);
+  }
+  $507fabe10e71c6fb$export$d90243b58daecda7.delete(windowObject);
+};
+function $507fabe10e71c6fb$export$2f1888112f558a7d(element) {
+  const documentObject = $431fbd86ca7dc216$export$b204af158042fbac(element);
+  let loadListener;
+  if (documentObject.readyState !== "loading")
+    $507fabe10e71c6fb$var$setupGlobalFocusEvents(element);
+  else {
+    loadListener = () => {
+      $507fabe10e71c6fb$var$setupGlobalFocusEvents(element);
+    };
+    documentObject.addEventListener("DOMContentLoaded", loadListener);
+  }
+  return () => $507fabe10e71c6fb$var$tearDownWindowFocusTracking(element, loadListener);
+}
+if (typeof document !== "undefined")
+  $507fabe10e71c6fb$export$2f1888112f558a7d();
+function $507fabe10e71c6fb$export$b9b3dfddab17db27() {
+  return $507fabe10e71c6fb$var$currentModality !== "pointer";
+}
+function $507fabe10e71c6fb$export$630ff653c5ada6a9() {
+  return $507fabe10e71c6fb$var$currentModality;
+}
+function $507fabe10e71c6fb$export$8397ddfc504fdb9a(modality) {
+  $507fabe10e71c6fb$var$currentModality = modality;
+  $507fabe10e71c6fb$var$triggerChangeHandlers(modality, null);
+}
+function $507fabe10e71c6fb$export$98e20ec92f614cfe() {
+  $507fabe10e71c6fb$var$setupGlobalFocusEvents();
+  let [modality, setModality] = useState($507fabe10e71c6fb$var$currentModality);
+  useEffect(() => {
+    let handler = () => {
+      setModality($507fabe10e71c6fb$var$currentModality);
+    };
+    $507fabe10e71c6fb$var$changeHandlers.add(handler);
+    return () => {
+      $507fabe10e71c6fb$var$changeHandlers.delete(handler);
+    };
+  }, []);
+  return $b5e257d569688ac6$export$535bd6ca7f90a273() ? null : modality;
+}
+const $507fabe10e71c6fb$var$nonTextInputTypes = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+function $507fabe10e71c6fb$var$isKeyboardFocusEvent(isTextInput, modality, e) {
+  var _e_target;
+  const IHTMLInputElement = typeof window !== "undefined" ? $431fbd86ca7dc216$export$f21a1ffae260145a(e === null || e === void 0 ? void 0 : e.target).HTMLInputElement : HTMLInputElement;
+  const IHTMLTextAreaElement = typeof window !== "undefined" ? $431fbd86ca7dc216$export$f21a1ffae260145a(e === null || e === void 0 ? void 0 : e.target).HTMLTextAreaElement : HTMLTextAreaElement;
+  const IHTMLElement = typeof window !== "undefined" ? $431fbd86ca7dc216$export$f21a1ffae260145a(e === null || e === void 0 ? void 0 : e.target).HTMLElement : HTMLElement;
+  const IKeyboardEvent = typeof window !== "undefined" ? $431fbd86ca7dc216$export$f21a1ffae260145a(e === null || e === void 0 ? void 0 : e.target).KeyboardEvent : KeyboardEvent;
+  isTextInput = isTextInput || (e === null || e === void 0 ? void 0 : e.target) instanceof IHTMLInputElement && !$507fabe10e71c6fb$var$nonTextInputTypes.has(e === null || e === void 0 ? void 0 : (_e_target = e.target) === null || _e_target === void 0 ? void 0 : _e_target.type) || (e === null || e === void 0 ? void 0 : e.target) instanceof IHTMLTextAreaElement || (e === null || e === void 0 ? void 0 : e.target) instanceof IHTMLElement && (e === null || e === void 0 ? void 0 : e.target.isContentEditable);
+  return !(isTextInput && modality === "keyboard" && e instanceof IKeyboardEvent && !$507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS[e.key]);
+}
+function $507fabe10e71c6fb$export$ec71b4b83ac08ec3(fn, deps, opts) {
+  $507fabe10e71c6fb$var$setupGlobalFocusEvents();
+  useEffect(() => {
+    let handler = (modality, e) => {
+      if (!$507fabe10e71c6fb$var$isKeyboardFocusEvent(!!(opts === null || opts === void 0 ? void 0 : opts.isTextInput), modality, e))
+        return;
+      fn($507fabe10e71c6fb$export$b9b3dfddab17db27());
+    };
+    $507fabe10e71c6fb$var$changeHandlers.add(handler);
+    return () => {
+      $507fabe10e71c6fb$var$changeHandlers.delete(handler);
+    };
+  }, deps);
+}
+function $9ab94262bd0047c7$export$420e68273165f4ec(props) {
+  let { isDisabled, onBlurWithin, onFocusWithin, onFocusWithinChange } = props;
+  let state = useRef({
+    isFocusWithin: false
+  });
+  let onBlur = useCallback((e) => {
+    if (state.current.isFocusWithin && !e.currentTarget.contains(e.relatedTarget)) {
+      state.current.isFocusWithin = false;
+      if (onBlurWithin)
+        onBlurWithin(e);
+      if (onFocusWithinChange)
+        onFocusWithinChange(false);
+    }
+  }, [
+    onBlurWithin,
+    onFocusWithinChange,
+    state
+  ]);
+  let onSyntheticFocus = $8a9cb279dc87e130$export$715c682d09d639cc(onBlur);
+  let onFocus = useCallback((e) => {
+    if (!state.current.isFocusWithin && document.activeElement === e.target) {
+      if (onFocusWithin)
+        onFocusWithin(e);
+      if (onFocusWithinChange)
+        onFocusWithinChange(true);
+      state.current.isFocusWithin = true;
+      onSyntheticFocus(e);
+    }
+  }, [
+    onFocusWithin,
+    onFocusWithinChange,
+    onSyntheticFocus
+  ]);
+  if (isDisabled)
+    return {
+      focusWithinProps: {
+        // These should not have been null, that would conflict in mergeProps
+        onFocus: void 0,
+        onBlur: void 0
+      }
+    };
+  return {
+    focusWithinProps: {
+      onFocus,
+      onBlur
+    }
+  };
+}
+let $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
+let $6179b936705e76d3$var$hoverCount = 0;
+function $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents() {
+  $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = true;
+  setTimeout(() => {
+    $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
+  }, 50);
+}
+function $6179b936705e76d3$var$handleGlobalPointerEvent(e) {
+  if (e.pointerType === "touch")
+    $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents();
+}
+function $6179b936705e76d3$var$setupGlobalTouchEvents() {
+  if (typeof document === "undefined")
+    return;
+  if (typeof PointerEvent !== "undefined")
+    document.addEventListener("pointerup", $6179b936705e76d3$var$handleGlobalPointerEvent);
+  else
+    document.addEventListener("touchend", $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);
+  $6179b936705e76d3$var$hoverCount++;
+  return () => {
+    $6179b936705e76d3$var$hoverCount--;
+    if ($6179b936705e76d3$var$hoverCount > 0)
+      return;
+    if (typeof PointerEvent !== "undefined")
+      document.removeEventListener("pointerup", $6179b936705e76d3$var$handleGlobalPointerEvent);
+    else
+      document.removeEventListener("touchend", $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);
+  };
+}
+function $6179b936705e76d3$export$ae780daf29e6d456(props) {
+  let { onHoverStart, onHoverChange, onHoverEnd, isDisabled } = props;
+  let [isHovered, setHovered] = useState(false);
+  let state = useRef({
+    isHovered: false,
+    ignoreEmulatedMouseEvents: false,
+    pointerType: "",
+    target: null
+  }).current;
+  useEffect($6179b936705e76d3$var$setupGlobalTouchEvents, []);
+  let { hoverProps, triggerHoverEnd } = useMemo(() => {
+    let triggerHoverStart = (event, pointerType) => {
+      state.pointerType = pointerType;
+      if (isDisabled || pointerType === "touch" || state.isHovered || !event.currentTarget.contains(event.target))
+        return;
+      state.isHovered = true;
+      let target = event.currentTarget;
+      state.target = target;
+      if (onHoverStart)
+        onHoverStart({
+          type: "hoverstart",
+          target,
+          pointerType
+        });
+      if (onHoverChange)
+        onHoverChange(true);
+      setHovered(true);
+    };
+    let triggerHoverEnd2 = (event, pointerType) => {
+      state.pointerType = "";
+      state.target = null;
+      if (pointerType === "touch" || !state.isHovered)
+        return;
+      state.isHovered = false;
+      let target = event.currentTarget;
+      if (onHoverEnd)
+        onHoverEnd({
+          type: "hoverend",
+          target,
+          pointerType
+        });
+      if (onHoverChange)
+        onHoverChange(false);
+      setHovered(false);
+    };
+    let hoverProps2 = {};
+    if (typeof PointerEvent !== "undefined") {
+      hoverProps2.onPointerEnter = (e) => {
+        if ($6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents && e.pointerType === "mouse")
+          return;
+        triggerHoverStart(e, e.pointerType);
+      };
+      hoverProps2.onPointerLeave = (e) => {
+        if (!isDisabled && e.currentTarget.contains(e.target))
+          triggerHoverEnd2(e, e.pointerType);
+      };
+    } else {
+      hoverProps2.onTouchStart = () => {
+        state.ignoreEmulatedMouseEvents = true;
+      };
+      hoverProps2.onMouseEnter = (e) => {
+        if (!state.ignoreEmulatedMouseEvents && !$6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents)
+          triggerHoverStart(e, "mouse");
+        state.ignoreEmulatedMouseEvents = false;
+      };
+      hoverProps2.onMouseLeave = (e) => {
+        if (!isDisabled && e.currentTarget.contains(e.target))
+          triggerHoverEnd2(e, "mouse");
+      };
+    }
+    return {
+      hoverProps: hoverProps2,
+      triggerHoverEnd: triggerHoverEnd2
+    };
+  }, [
+    onHoverStart,
+    onHoverChange,
+    onHoverEnd,
+    isDisabled,
+    state
+  ]);
+  useEffect(() => {
+    if (isDisabled)
+      triggerHoverEnd({
+        currentTarget: state.target
+      }, state.pointerType);
+  }, [
+    isDisabled
+  ]);
+  return {
+    hoverProps,
+    isHovered
+  };
+}
+function $6a99195332edec8b$export$80f3e147d781571c(element) {
+  const ownerDocument = $431fbd86ca7dc216$export$b204af158042fbac(element);
+  if ($507fabe10e71c6fb$export$630ff653c5ada6a9() === "virtual") {
+    let lastFocusedElement = ownerDocument.activeElement;
+    $bbed8b41f857bcc0$export$24490316f764c430(() => {
+      if (ownerDocument.activeElement === lastFocusedElement && element.isConnected)
+        $7215afc6de606d6b$export$de79e2c695e052f3(element);
+    });
+  } else
+    $7215afc6de606d6b$export$de79e2c695e052f3(element);
+}
+export {
+  $6179b936705e76d3$export$ae780daf29e6d456 as $,
+  $507fabe10e71c6fb$export$b9b3dfddab17db27 as a,
+  $507fabe10e71c6fb$export$ec71b4b83ac08ec3 as b,
+  $a1ea59d68270f0dd$export$f8168d8dd8fd66e6 as c,
+  $9ab94262bd0047c7$export$420e68273165f4ec as d,
+  $458b0a5536c1a7cf$export$40bfa8c7b0832715 as e,
+  $431fbd86ca7dc216$export$f21a1ffae260145a as f,
+  $431fbd86ca7dc216$export$b204af158042fbac as g,
+  $6a99195332edec8b$export$80f3e147d781571c as h,
+  $507fabe10e71c6fb$export$8397ddfc504fdb9a as i,
+  $c87311424ea30a05$export$fedb369cb70207f1 as j,
+  $bbed8b41f857bcc0$export$24490316f764c430 as k,
+  $e7801be82b4b2a53$export$4debdb1a3f0fa79e as l,
+  $7215afc6de606d6b$export$de79e2c695e052f3 as m,
+  $c87311424ea30a05$export$b7d78993b74f766d as n,
+  $c87311424ea30a05$export$9ac100e40613ea10 as o,
+  $c87311424ea30a05$export$78551043582a6a98 as p,
+  $c87311424ea30a05$export$7bef049ce92e4224 as q,
+  $6a7db85432448f7f$export$29bf1b5f2c56cf63 as r,
+  $6a7db85432448f7f$export$60278871457622de as s,
+  $507fabe10e71c6fb$export$630ff653c5ada6a9 as t,
+  $c87311424ea30a05$export$a11b0059900ceec8 as u,
+  $c87311424ea30a05$export$e1865c3bedcd822b as v,
+  $507fabe10e71c6fb$export$98e20ec92f614cfe as w,
+  $c87311424ea30a05$export$186c6964ca17d99 as x
+};