@tamagui/focus-scope 2.7.7 → 3.0.0-beta.643.1

package/dist/esm/FocusScope.mjs

@@ -1,358 +1,361 @@
-import { useComposedRefs } from "@tamagui/compose-refs";
+import { createRefComponent, useComposedRefs } from "@tamagui/compose-refs";
 import { isWeb, useIsomorphicLayoutEffect } from "@tamagui/constants";
+import { createChangeEventDetails } from "@tamagui/core";
 import { idle, useAsyncEffect } from "@tamagui/use-async";
 import { useEvent } from "@tamagui/use-event";
 import * as React from "react";
 import { useFocusScopeControllerContext } from "./FocusScopeController.mjs";
-import { Fragment, jsx } from "react/jsx-runtime";
-const AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
-const AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
-const EVENT_OPTIONS = {
-  bubbles: false,
-  cancelable: true
-};
-const FocusScope = React.forwardRef(function FocusScope2({
-  __scopeFocusScope,
-  ...props
-}, forwardedRef) {
-  const context = useFocusScopeControllerContext("FocusScope", __scopeFocusScope, {
-    warn: false,
-    fallback: {}
-  });
-  const mergedProps = {
-    ...props,
-    enabled: context.enabled ?? props.enabled,
-    loop: context.loop ?? props.loop,
-    trapped: context.trapped ?? props.trapped,
-    onMountAutoFocus: context.onMountAutoFocus ?? props.onMountAutoFocus,
-    onUnmountAutoFocus: context.onUnmountAutoFocus ?? props.onUnmountAutoFocus,
-    forceUnmount: context.forceUnmount ?? props.forceUnmount,
-    focusOnIdle: context.focusOnIdle ?? props.focusOnIdle
-  };
-  const childProps = useFocusScope(mergedProps, forwardedRef);
-  if (typeof mergedProps.children === "function") {
-    return /* @__PURE__ */jsx(Fragment, {
-      children: mergedProps.children(childProps)
-    });
-  }
-  return React.cloneElement(React.Children.only(mergedProps.children), childProps);
+import { jsx } from "react/jsx-runtime";
+
+const FOCUS_SCOPE_STYLE = { display: "contents" };
+const FocusScope = createRefComponent(function FocusScope2({ __scopeFocusScope, ...props }, forwardedRef) {
+	const context = useFocusScopeControllerContext("FocusScope", __scopeFocusScope, {
+		warn: false,
+		fallback: {}
+	});
+	const mergedProps = {
+		...props,
+		enabled: context.enabled ?? props.enabled,
+		loop: context.loop ?? props.loop,
+		trapped: context.trapped ?? props.trapped,
+		noFocus: context.noFocus ?? props.noFocus,
+		onMountAutoFocus: context.onMountAutoFocus ?? props.onMountAutoFocus,
+		onUnmountAutoFocus: context.onUnmountAutoFocus ?? props.onUnmountAutoFocus,
+		forceUnmount: context.forceUnmount ?? props.forceUnmount,
+		focusOnIdle: context.focusOnIdle ?? props.focusOnIdle
+	};
+	const childProps = useFocusScope(mergedProps, forwardedRef);
+	const { ref, style, ...scopeProps } = childProps;
+	const children = mergedProps.children;
+	return /* @__PURE__ */ jsx("div", {
+		...scopeProps,
+		ref,
+		style: getFocusScopeStyle(style),
+		children
+	});
 });
+function getFocusScopeStyle(style) {
+	if (!style) return FOCUS_SCOPE_STYLE;
+	return {
+		...style,
+		display: "contents"
+	};
+}
 function setupFocusTrap(container, lastFocusedElementRef, focusScope) {
-  const controller = new AbortController();
-  let rafId = null;
-  function scheduleRefocus() {
-    if (rafId) return;
-    const elementToFocus = lastFocusedElementRef.current;
-    rafId = requestAnimationFrame(() => {
-      rafId = null;
-      if (focusScope.paused) return;
-      if (focusScope.stopped) return;
-      if (!container.isConnected) return;
-      if (!container.contains(document.activeElement)) {
-        focus(elementToFocus);
-      }
-    });
-  }
-  function handleFocusIn(event) {
-    if (focusScope.paused) return;
-    const target = event.target;
-    if (container.contains(target)) {
-      target?.addEventListener("blur", handleBlur, {
-        signal: controller.signal
-      });
-      lastFocusedElementRef.current = target;
-    } else if (target?.contains(container)) {} else {
-      scheduleRefocus();
-    }
-  }
-  function handleFocusOut(event) {
-    controller.abort();
-    if (focusScope.paused) return;
-    const relatedTarget = event.relatedTarget;
-    if (relatedTarget === null) return;
-    if (relatedTarget.contains(container)) return;
-    if (!container.contains(relatedTarget)) {
-      scheduleRefocus();
-    }
-  }
-  function handleBlur() {}
-  document.addEventListener("focusin", handleFocusIn);
-  document.addEventListener("focusout", handleFocusOut);
-  return () => {
-    if (rafId) {
-      cancelAnimationFrame(rafId);
-      rafId = null;
-    }
-    controller.abort();
-    document.removeEventListener("focusin", handleFocusIn);
-    document.removeEventListener("focusout", handleFocusOut);
-  };
+	const controller = new AbortController();
+	let rafId = null;
+	function scheduleRefocus() {
+		if (rafId) return;
+		const elementToFocus = lastFocusedElementRef.current;
+		rafId = requestAnimationFrame(() => {
+			rafId = null;
+			if (focusScope.paused) return;
+			if (focusScope.stopped) return;
+			if (!container.isConnected) return;
+			if (!container.contains(document.activeElement)) {
+				focus(elementToFocus);
+			}
+		});
+	}
+	function handleFocusIn(event) {
+		if (focusScope.paused) return;
+		const target = event.target;
+		if (container.contains(target)) {
+			target?.addEventListener("blur", handleBlur, { signal: controller.signal });
+			lastFocusedElementRef.current = target;
+		} else if (target?.contains(container)) {} else {
+			scheduleRefocus();
+		}
+	}
+	function handleFocusOut(event) {
+		controller.abort();
+		if (focusScope.paused) return;
+		const relatedTarget = event.relatedTarget;
+		if (relatedTarget === null) return;
+		if (relatedTarget.contains(container)) return;
+		if (!container.contains(relatedTarget)) {
+			scheduleRefocus();
+		}
+	}
+	function handleBlur() {}
+	document.addEventListener("focusin", handleFocusIn);
+	document.addEventListener("focusout", handleFocusOut);
+	return () => {
+		if (rafId) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+		controller.abort();
+		document.removeEventListener("focusin", handleFocusIn);
+		document.removeEventListener("focusout", handleFocusOut);
+	};
 }
 function useFocusScope(props, forwardedRef) {
-  const {
-    loop = false,
-    enabled = true,
-    trapped = false,
-    onMountAutoFocus: onMountAutoFocusProp,
-    onUnmountAutoFocus: onUnmountAutoFocusProp,
-    forceUnmount,
-    focusOnIdle = true,
-    children,
-    ...scopeProps
-  } = props;
-  const [container, setContainer] = React.useState(null);
-  const containerRef = React.useRef(null);
-  const onMountAutoFocus = useEvent(onMountAutoFocusProp);
-  const onUnmountAutoFocus = useEvent(onUnmountAutoFocusProp);
-  const lastFocusedElementRef = React.useRef(null);
-  const focusScopeRef = React.useRef({
-    paused: false,
-    stopped: false,
-    // set to true when cleanup starts, signals trap to stop
-    pause() {
-      this.paused = true;
-    },
-    resume() {
-      this.paused = false;
-    },
-    stop() {
-      this.stopped = true;
-    }
-  });
-  const focusScope = focusScopeRef.current;
-  const trapCleanupRef = React.useRef(null);
-  const setContainerRef = React.useCallback(node => {
-    if (trapCleanupRef.current) {
-      trapCleanupRef.current();
-      trapCleanupRef.current = null;
-    }
-    containerRef.current = node;
-    if (isWeb && node && enabled && trapped) {
-      trapCleanupRef.current = setupFocusTrap(node, lastFocusedElementRef, focusScopeRef.current);
-    }
-    setContainer(node);
-  }, [enabled, trapped]);
-  const composedRefs = useComposedRefs(forwardedRef, setContainerRef);
-  useIsomorphicLayoutEffect(() => {
-    if (!trapped) {
-      focusScope.stopped = true;
-      if (trapCleanupRef.current) {
-        trapCleanupRef.current();
-        trapCleanupRef.current = null;
-      }
-    }
-    return () => {
-      if (trapCleanupRef.current) {
-        trapCleanupRef.current();
-        trapCleanupRef.current = null;
-      }
-    };
-  }, [trapped, focusScope]);
-  useAsyncEffect(async signal => {
-    if (!enabled) return;
-    if (!container) return;
-    if (forceUnmount) return;
-    if (trapped) {
-      focusScope.stopped = false;
-    }
-    focusScopesStack.add(focusScope);
-    const previouslyFocusedElement = document.activeElement;
-    const hasFocusedCandidate = container.contains(previouslyFocusedElement) && previouslyFocusedElement !== null && !isHidden(previouslyFocusedElement, {
-      upTo: container
-    });
-    if (!hasFocusedCandidate) {
-      const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
-      container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
-      container.dispatchEvent(mountEvent);
-      if (!mountEvent.defaultPrevented) {
-        if (focusOnIdle) {
-          await idle(signal, typeof focusOnIdle == "object" ? focusOnIdle : {
-            // we can't wait too long or else user can take an action and then we focus
-            max: 200,
-            min: typeof focusOnIdle == "number" ? focusOnIdle : 16
-          });
-        }
-        const allCandidates = getTabbableCandidates(container);
-        const linkedRemoved = removeLinks(allCandidates);
-        const visibleCandidates = linkedRemoved.filter(candidate => !isHidden(candidate, {
-          upTo: container
-        }));
-        focusFirst(visibleCandidates, {
-          select: true
-        });
-        if (visibleCandidates.length > 0) {
-          lastFocusedElementRef.current = visibleCandidates[0];
-        } else {
-          lastFocusedElementRef.current = container;
-        }
-        if (document.activeElement === previouslyFocusedElement && visibleCandidates.length === 0) {
-          focus(container);
-        }
-      }
-    }
-    return () => {
-      focusScope.stop();
-      container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
-      const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
-      container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-      container.dispatchEvent(unmountEvent);
-      if (!unmountEvent.defaultPrevented) {
-        const currentFocus = document.activeElement;
-        const focusHasMovedOutside = currentFocus && currentFocus !== document.body && currentFocus !== container && !container.contains(currentFocus);
-        if (!focusHasMovedOutside) {
-          focus(previouslyFocusedElement ?? document.body, {
-            select: true
-          });
-        }
-      }
-      container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-      focusScopesStack.remove(focusScope);
-    };
-  }, [enabled, container, forceUnmount, onMountAutoFocus, onUnmountAutoFocus, focusScope, focusOnIdle]);
-  const handleKeyDown = React.useCallback(event => {
-    if (!trapped) return;
-    if (!loop) return;
-    if (focusScope.paused) return;
-    if (!enabled) return;
-    if (!container) return;
-    const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
-    const focusedElement = document.activeElement;
-    if (isTabKey && focusedElement) {
-      const [first, last] = getTabbableEdges(container);
-      const hasTabbableElementsInside = first && last;
-      if (!hasTabbableElementsInside) {
-        if (focusedElement === container) event.preventDefault();
-      } else {
-        if (!event.shiftKey && focusedElement === last) {
-          event.preventDefault();
-          if (loop) focus(first, {
-            select: true
-          });
-        } else if (event.shiftKey && focusedElement === first) {
-          event.preventDefault();
-          if (loop) focus(last, {
-            select: true
-          });
-        }
-      }
-    }
-  }, [loop, trapped, focusScope.paused, enabled, container]);
-  React.useEffect(() => {
-    if (!container) return;
-    if (!trapped) return;
-    if (!loop) return;
-    if (!enabled) return;
-    const handleKeyDownCapture = event => {
-      if (event.key === "Tab") {
-        handleKeyDown(event);
-      }
-    };
-    container.addEventListener("keydown", handleKeyDownCapture, true);
-    return () => {
-      container.removeEventListener("keydown", handleKeyDownCapture, true);
-    };
-  }, [container, trapped, loop, enabled, handleKeyDown]);
-  const existingOnKeyDown = scopeProps.onKeyDown;
-  const composedOnKeyDown = React.useCallback(event => {
-    existingOnKeyDown?.(event);
-  }, [existingOnKeyDown]);
-  return {
-    ...scopeProps,
-    ref: composedRefs,
-    onKeyDown: composedOnKeyDown
-  };
+	const { loop = false, enabled = true, trapped: trappedProp = false, noFocus = false, onMountAutoFocus: onMountAutoFocusProp, onUnmountAutoFocus: onUnmountAutoFocusProp, forceUnmount, focusOnIdle = true, children: _children, asChild: _asChild, ...scopeProps } = props;
+	const trapped = noFocus ? false : trappedProp;
+	const [container, setContainer] = React.useState(null);
+	const containerRef = React.useRef(null);
+	const onMountAutoFocus = useEvent(onMountAutoFocusProp);
+	const onUnmountAutoFocus = useEvent(onUnmountAutoFocusProp);
+	const lastFocusedElementRef = React.useRef(null);
+	const focusScopeRef = React.useRef({
+		paused: false,
+		stopped: false,
+		pause() {
+			this.paused = true;
+		},
+		resume() {
+			this.paused = false;
+		},
+		stop() {
+			this.stopped = true;
+		}
+	});
+	const focusScope = focusScopeRef.current;
+	const trapCleanupRef = React.useRef(null);
+	const setContainerRef = React.useCallback((node) => {
+		if (trapCleanupRef.current) {
+			trapCleanupRef.current();
+			trapCleanupRef.current = null;
+		}
+		containerRef.current = node;
+		if (isWeb && node && enabled && trapped) {
+			trapCleanupRef.current = setupFocusTrap(node, lastFocusedElementRef, focusScopeRef.current);
+		}
+		setContainer(node);
+	}, [enabled, trapped]);
+	const composedRefs = useComposedRefs(forwardedRef, setContainerRef);
+	useIsomorphicLayoutEffect(() => {
+		if (!trapped) {
+			focusScope.stopped = true;
+			if (trapCleanupRef.current) {
+				trapCleanupRef.current();
+				trapCleanupRef.current = null;
+			}
+		}
+		return () => {
+			if (trapCleanupRef.current) {
+				trapCleanupRef.current();
+				trapCleanupRef.current = null;
+			}
+		};
+	}, [trapped, focusScope]);
+	useIsomorphicLayoutEffect(() => {
+		if (!isWeb) return;
+		if (!enabled || !noFocus || !container) return;
+		const blurActiveElement = () => {
+			const active = document.activeElement;
+			if (active && active !== document.body && typeof active.blur === "function") {
+				active.blur();
+			}
+		};
+		blurActiveElement();
+		document.addEventListener("focusin", blurActiveElement, true);
+		return () => {
+			document.removeEventListener("focusin", blurActiveElement, true);
+		};
+	}, [
+		enabled,
+		noFocus,
+		container
+	]);
+	useAsyncEffect(async (signal) => {
+		if (!enabled) return;
+		if (!container) return;
+		if (forceUnmount) return;
+		if (noFocus) return;
+		if (trapped) {
+			focusScope.stopped = false;
+		}
+		focusScopesStack.add(focusScope);
+		const previouslyFocusedElement = document.activeElement;
+		const hasFocusedCandidate = container.contains(previouslyFocusedElement) && previouslyFocusedElement !== null && !isHidden(previouslyFocusedElement, { upTo: container });
+		if (!hasFocusedCandidate) {
+			const details = createChangeEventDetails("trigger-focus");
+			onMountAutoFocus?.(details);
+			if (!details.isCanceled) {
+				if (focusOnIdle) {
+					await idle(signal, typeof focusOnIdle == "object" ? focusOnIdle : {
+						max: 200,
+						min: typeof focusOnIdle == "number" ? focusOnIdle : 16
+					});
+				}
+				const allCandidates = getTabbableCandidates(container);
+				const linkedRemoved = removeLinks(allCandidates);
+				const visibleCandidates = linkedRemoved.filter((candidate) => !isHidden(candidate, { upTo: container }));
+				focusFirst(visibleCandidates, { select: true });
+				if (visibleCandidates.length > 0) {
+					lastFocusedElementRef.current = visibleCandidates[0];
+				} else {
+					lastFocusedElementRef.current = container;
+				}
+				if (document.activeElement === previouslyFocusedElement && visibleCandidates.length === 0) {
+					focus(container);
+				}
+			}
+		}
+		return () => {
+			focusScope.stop();
+			const details = createChangeEventDetails("focus-out");
+			onUnmountAutoFocus?.(details);
+			if (!details.isCanceled) {
+				const currentFocus = document.activeElement;
+				const focusHasMovedOutside = currentFocus && currentFocus !== document.body && currentFocus !== container && !container.contains(currentFocus);
+				if (!focusHasMovedOutside) {
+					focus(previouslyFocusedElement ?? document.body, { select: true });
+				}
+			}
+			focusScopesStack.remove(focusScope);
+		};
+	}, [
+		enabled,
+		container,
+		forceUnmount,
+		noFocus,
+		onMountAutoFocus,
+		onUnmountAutoFocus,
+		focusScope,
+		focusOnIdle
+	]);
+	const handleKeyDown = React.useCallback((event) => {
+		if (!trapped) return;
+		if (!loop) return;
+		if (focusScope.paused) return;
+		if (!enabled) return;
+		if (!container) return;
+		const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+		const focusedElement = document.activeElement;
+		if (isTabKey && focusedElement) {
+			const [first, last] = getTabbableEdges(container);
+			const hasTabbableElementsInside = first && last;
+			if (!hasTabbableElementsInside) {
+				if (focusedElement === container) event.preventDefault();
+			} else {
+				if (!event.shiftKey && focusedElement === last) {
+					event.preventDefault();
+					if (loop) focus(first, { select: true });
+				} else if (event.shiftKey && focusedElement === first) {
+					event.preventDefault();
+					if (loop) focus(last, { select: true });
+				}
+			}
+		}
+	}, [
+		loop,
+		trapped,
+		focusScope.paused,
+		enabled,
+		container
+	]);
+	React.useEffect(() => {
+		if (!container) return;
+		if (!trapped) return;
+		if (!loop) return;
+		if (!enabled) return;
+		const handleKeyDownCapture = (event) => {
+			if (event.key === "Tab") {
+				handleKeyDown(event);
+			}
+		};
+		container.addEventListener("keydown", handleKeyDownCapture, true);
+		return () => {
+			container.removeEventListener("keydown", handleKeyDownCapture, true);
+		};
+	}, [
+		container,
+		trapped,
+		loop,
+		enabled,
+		handleKeyDown
+	]);
+	const existingOnKeyDown = scopeProps.onKeyDown;
+	const composedOnKeyDown = React.useCallback((event) => {
+		existingOnKeyDown?.(event);
+	}, [existingOnKeyDown]);
+	return {
+		...scopeProps,
+		ref: composedRefs,
+		onKeyDown: composedOnKeyDown
+	};
 }
-function focusFirst(candidates, {
-  select = false
-} = {}) {
-  const previouslyFocusedElement = document.activeElement;
-  for (const candidate of candidates) {
-    focus(candidate, {
-      select
-    });
-    if (document.activeElement !== previouslyFocusedElement) return;
-  }
+function focusFirst(candidates, { select = false } = {}) {
+	const previouslyFocusedElement = document.activeElement;
+	for (const candidate of candidates) {
+		focus(candidate, { select });
+		if (document.activeElement !== previouslyFocusedElement) return;
+	}
 }
 function getTabbableEdges(container) {
-  const candidates = getTabbableCandidates(container);
-  const first = findVisible(candidates, container);
-  const last = findVisible(candidates.reverse(), container);
-  return [first, last];
+	const candidates = getTabbableCandidates(container);
+	const first = findVisible(candidates, container);
+	const last = findVisible(candidates.reverse(), container);
+	return [first, last];
 }
 function getTabbableCandidates(container) {
-  const nodes = [];
-  const walker = document.createTreeWalker(container, 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 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-    }
-  });
-  while (walker.nextNode()) nodes.push(walker.currentNode);
-  return nodes;
+	const nodes = [];
+	const walker = document.createTreeWalker(container, 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 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+	} });
+	while (walker.nextNode()) nodes.push(walker.currentNode);
+	return nodes;
 }
 function findVisible(elements, container) {
-  for (const element of elements) {
-    if (!isHidden(element, {
-      upTo: container
-    })) return element;
-  }
+	for (const element of elements) {
+		if (!isHidden(element, { upTo: container })) return element;
+	}
 }
-function isHidden(node, {
-  upTo
-}) {
-  if (getComputedStyle(node).visibility === "hidden") return true;
-  while (node) {
-    if (upTo !== void 0 && node === upTo) return false;
-    if (getComputedStyle(node).display === "none") return true;
-    node = node.parentElement;
-  }
-  return false;
+function isHidden(node, { upTo }) {
+	if (getComputedStyle(node).visibility === "hidden") return true;
+	while (node) {
+		if (upTo !== void 0 && node === upTo) return false;
+		if (getComputedStyle(node).display === "none") return true;
+		node = node.parentElement;
+	}
+	return false;
 }
 function isSelectableInput(element) {
-  return element instanceof HTMLInputElement && "select" in element;
+	return element instanceof HTMLInputElement && "select" in element;
 }
-function focus(element, {
-  select = false
-} = {}) {
-  if (element?.focus) {
-    const previouslyFocusedElement = document.activeElement;
-    try {
-      element.focus({
-        preventScroll: true
-      });
-      if (element !== previouslyFocusedElement && isSelectableInput(element) && select) element.select();
-    } catch (error) {}
-  }
+function focus(element, { select = false } = {}) {
+	if (element?.focus) {
+		const previouslyFocusedElement = document.activeElement;
+		try {
+			element.focus({ preventScroll: true });
+			if (element !== previouslyFocusedElement && isSelectableInput(element) && select) element.select();
+		} catch (error) {}
+	}
 }
 const focusScopesStack = createFocusScopesStack();
 function createFocusScopesStack() {
-  let stack = [];
-  return {
-    add(focusScope) {
-      const activeFocusScope = stack[0];
-      if (focusScope !== activeFocusScope) {
-        activeFocusScope?.pause();
-      }
-      stack = arrayRemove(stack, focusScope);
-      stack.unshift(focusScope);
-    },
-    remove(focusScope) {
-      stack = arrayRemove(stack, focusScope);
-      stack[0]?.resume();
-    }
-  };
+	let stack = [];
+	return {
+		add(focusScope) {
+			const activeFocusScope = stack[0];
+			if (focusScope !== activeFocusScope) {
+				activeFocusScope?.pause();
+			}
+			stack = arrayRemove(stack, focusScope);
+			stack.unshift(focusScope);
+		},
+		remove(focusScope) {
+			stack = arrayRemove(stack, focusScope);
+			stack[0]?.resume();
+		}
+	};
 }
 function arrayRemove(array, item) {
-  const updatedArray = [...array];
-  const index = updatedArray.indexOf(item);
-  if (index !== -1) {
-    updatedArray.splice(index, 1);
-  }
-  return updatedArray;
+	const updatedArray = [...array];
+	const index = updatedArray.indexOf(item);
+	if (index !== -1) {
+		updatedArray.splice(index, 1);
+	}
+	return updatedArray;
 }
 function removeLinks(items) {
-  return items.filter(item => item.tagName !== "A");
+	return items.filter((item) => item.tagName !== "A");
 }
+
 export { FocusScope, useFocusScope };
 //# sourceMappingURL=FocusScope.mjs.map