@vizejs/ui 0.345.0 → 0.350.2

package/dist/focus-scope-D9U1aj67.mjs

@@ -0,0 +1,340 @@
+import { a as focusableElements, c as documentOrder, d as readTarget, f as resolveMoveOptions, i as focusElement, l as readBoolean, m as validateOptions, n as createAutoFocusEvent, o as isUsableTarget, p as surfaceErrors, r as deepActiveElement, s as capture, t as containsComposed, u as readRoot } from "./focus-scope-dom-DBwNEWxG.mjs";
+import { getCurrentInstance, getCurrentScope, onMounted, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/focus-scope-manager.ts
+/** Create stable traversal methods while keeping controller lifecycle orchestration focused. */
+function createFocusScopeManager({ assertAlive, list, root }) {
+	const move = (position, values) => {
+		assertAlive();
+		const scopeRoot = root();
+		if (!scopeRoot) return null;
+		const options = resolveMoveOptions(values);
+		const candidates = list(scopeRoot, options);
+		let target;
+		if (position === "first") target = candidates[0];
+		else if (position === "last") target = candidates.at(-1);
+		else {
+			const from = "from" in options ? options.from : deepActiveElement(scopeRoot.ownerDocument);
+			const index = from ? candidates.indexOf(from) : -1;
+			if (position === "next") target = candidates[index + 1] ?? (options.wrap ? candidates[0] : void 0);
+			else target = index < 0 ? candidates.at(-1) : candidates[index - 1] ?? (options.wrap ? candidates.at(-1) : void 0);
+		}
+		if (target) focusElement(target, options.preventScroll);
+		return target ?? null;
+	};
+	return Object.freeze({
+		focusFirst: (options) => move("first", options),
+		focusLast: (options) => move("last", options),
+		focusNext: (options) => move("next", options),
+		focusPrevious: (options) => move("previous", options)
+	});
+}
+//#endregion
+//#region src/focus-scope-stack.ts
+const documentScopes = /* @__PURE__ */ new WeakMap();
+function scopesFor(document) {
+	let scopes = documentScopes.get(document);
+	if (!scopes) {
+		scopes = [];
+		documentScopes.set(document, scopes);
+	}
+	return scopes;
+}
+function attachScope(token, root) {
+	if (token.document === root.ownerDocument) {
+		token.root = root;
+		return;
+	}
+	detachScope(token);
+	token.document = root.ownerDocument;
+	token.root = root;
+	scopesFor(root.ownerDocument).push(token);
+}
+function detachScope(token) {
+	const document = token.document;
+	if (document) {
+		const scopes = scopesFor(document);
+		const index = scopes.indexOf(token);
+		if (index >= 0) scopes.splice(index, 1);
+	}
+	token.document = null;
+	token.root = null;
+}
+function containmentOwner(document) {
+	const scopes = scopesFor(document);
+	for (let index = scopes.length - 1; index >= 0; index--) {
+		const token = scopes[index];
+		try {
+			if (token?.readContain()) return token;
+		} catch {}
+	}
+	return null;
+}
+function rootsOwnedBy(token) {
+	const document = token.document;
+	if (!document) return [];
+	const scopes = scopesFor(document);
+	const index = scopes.indexOf(token);
+	if (index < 0) return [];
+	return scopes.slice(index).flatMap(({ root }) => root ? [root] : []);
+}
+function parentScope(token) {
+	const document = token.document;
+	if (!document) return null;
+	const scopes = scopesFor(document);
+	const index = scopes.indexOf(token);
+	return index > 0 ? scopes[index - 1] ?? null : null;
+}
+//#endregion
+//#region src/use-focus-scope.ts
+const setupDiagnostic = "VIZE_UI_FOCUS_SCOPE_SETUP";
+/** Create, mount-activate, and scope-dispose a focus scope from Vue setup. */
+function useFocusScope(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createFocusScope(options);
+	if (getCurrentInstance()) onMounted(controller.activate);
+	else controller.activate();
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+//#region src/focus-scope.ts
+const disposedDiagnostic = "VIZE_UI_FOCUS_SCOPE_DISPOSED";
+const rootDiagnostic = "VIZE_UI_FOCUS_SCOPE_ROOT";
+/** Create an SSR-safe focus scope with containment, traversal, and restoration. */
+function createFocusScope(options) {
+	validateOptions(options);
+	const activeState = shallowRef(false);
+	const token = {
+		document: null,
+		root: null,
+		lastFocused: null,
+		readContain: () => readBoolean(options.contain, "contain")
+	};
+	let disposed = false;
+	let observer = null;
+	let capturedTarget = null;
+	let restoreCandidates = [];
+	let restoreIndex = -1;
+	let restorationCaptured = false;
+	let entryHandled = false;
+	let guarding = false;
+	const assertAlive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const root = () => token.root ?? readRoot(options.root);
+	const accepted = (element, local) => options.accept?.(element) !== false && local?.(element) !== false;
+	const list = (scopeRoot, values) => {
+		const resolved = resolveMoveOptions(values);
+		return focusableElements(scopeRoot, {
+			includeProgrammatic: resolved.includeProgrammatic,
+			accept: (element) => accepted(element, resolved.accept)
+		});
+	};
+	const focusFallback = (scopeRoot) => {
+		const candidate = readTarget(options.fallbackFocus?.(), "fallbackFocus");
+		if (candidate && !containsComposed(scopeRoot, candidate)) throw new Error(`${rootDiagnostic}: fallbackFocus must resolve inside the scope`);
+		if (isUsableTarget(candidate)) return candidate;
+		const htmlRoot = scopeRoot;
+		return htmlRoot.namespaceURI === "http://www.w3.org/1999/xhtml" && typeof htmlRoot.focus === "function" && htmlRoot.hasAttribute("tabindex") && isUsableTarget(htmlRoot) ? htmlRoot : null;
+	};
+	const manager = createFocusScopeManager({
+		assertAlive,
+		list,
+		root
+	});
+	const ownedCandidates = () => documentOrder(rootsOwnedBy(token).flatMap((ownedRoot) => list(ownedRoot)));
+	const recover = () => {
+		if (guarding || token.document === null || containmentOwner(token.document) !== token) return;
+		const roots = rootsOwnedBy(token);
+		const active = deepActiveElement(token.document);
+		if (isUsableTarget(active) && roots.some((ownedRoot) => containsComposed(ownedRoot, active))) return;
+		const candidates = ownedCandidates();
+		const target = (token.lastFocused && roots.some((ownedRoot) => containsComposed(ownedRoot, token.lastFocused)) && isUsableTarget(token.lastFocused) ? token.lastFocused : candidates[0]) ?? (token.root ? focusFallback(token.root) : null);
+		if (!target) return;
+		guarding = true;
+		try {
+			focusElement(target);
+		} finally {
+			guarding = false;
+		}
+	};
+	const onFocusin = (event) => {
+		if (token.document === null || containmentOwner(token.document) !== token) return;
+		const target = event.composedPath?.()[0] ?? event.target;
+		if (isUsableTarget(target) && rootsOwnedBy(token).some((ownedRoot) => containsComposed(ownedRoot, target))) {
+			token.lastFocused = target;
+			return;
+		}
+		recover();
+	};
+	const onKeydown = (event) => {
+		if (event.key !== "Tab" || event.altKey || event.ctrlKey || event.metaKey || event.defaultPrevented || token.document === null || containmentOwner(token.document) !== token) return;
+		const candidates = ownedCandidates();
+		const current = deepActiveElement(token.document);
+		const index = current ? candidates.indexOf(current) : -1;
+		const target = event.shiftKey ? index <= 0 ? candidates.at(-1) : void 0 : index < 0 || index === candidates.length - 1 ? candidates[0] : void 0;
+		if (target) {
+			event.preventDefault();
+			focusElement(target);
+		} else if (candidates.length === 0 && token.root) {
+			event.preventDefault();
+			const fallback = focusFallback(token.root);
+			if (fallback) focusElement(fallback);
+		}
+	};
+	const detachDom = () => {
+		observer?.disconnect();
+		observer = null;
+		token.document?.removeEventListener("focusin", onFocusin, true);
+		token.document?.removeEventListener("keydown", onKeydown, true);
+		detachScope(token);
+	};
+	const observe = (scopeRoot) => {
+		observer?.disconnect();
+		observer = null;
+		const Observer = scopeRoot.ownerDocument.defaultView?.MutationObserver;
+		if (!Observer) return;
+		observer = new Observer(recover);
+		observer.observe(scopeRoot, {
+			subtree: true,
+			childList: true,
+			attributes: true,
+			attributeFilter: [
+				"aria-hidden",
+				"class",
+				"contenteditable",
+				"controls",
+				"disabled",
+				"hidden",
+				"href",
+				"inert",
+				"open",
+				"style",
+				"tabindex",
+				"type"
+			]
+		});
+		const documentRoot = scopeRoot.ownerDocument.documentElement;
+		if (documentRoot && documentRoot !== scopeRoot) observer.observe(documentRoot, {
+			childList: true,
+			subtree: true
+		});
+	};
+	const captureRestoration = (scopeRoot) => {
+		if (restorationCaptured) return;
+		restorationCaptured = true;
+		capturedTarget = deepActiveElement(scopeRoot.ownerDocument);
+		if (!readBoolean(options.restoreFocus, "restoreFocus")) return;
+		const body = scopeRoot.ownerDocument.body;
+		restoreCandidates = body ? focusableElements(body) : [];
+		restoreIndex = capturedTarget ? restoreCandidates.indexOf(capturedTarget) : -1;
+	};
+	const enter = (scopeRoot, errors) => {
+		if (entryHandled || !readBoolean(options.autoFocus, "autoFocus")) return;
+		entryHandled = true;
+		let target = readTarget(options.initialFocus?.(), "initialFocus");
+		if (target && !containsComposed(scopeRoot, target)) throw new Error(`${rootDiagnostic}: initialFocus must resolve inside the scope`);
+		if (!isUsableTarget(target)) target = null;
+		target = target ?? list(scopeRoot, { includeProgrammatic: true })[0] ?? focusFallback(scopeRoot);
+		const event = createAutoFocusEvent("mount", target);
+		capture(errors, () => options.onMountAutoFocus?.(event));
+		if (!event.defaultPrevented && target) capture(errors, () => focusElement(target));
+	};
+	const refresh = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		const nextRoot = readRoot(options.root);
+		if (nextRoot !== token.root) {
+			const sameDocument = nextRoot !== null && token.document === nextRoot.ownerDocument;
+			if (!sameDocument) detachDom();
+			if (nextRoot) {
+				captureRestoration(nextRoot);
+				attachScope(token, nextRoot);
+				if (!sameDocument) {
+					nextRoot.ownerDocument.addEventListener("focusin", onFocusin, true);
+					nextRoot.ownerDocument.addEventListener("keydown", onKeydown, true);
+				}
+				observe(nextRoot);
+				const errors = [];
+				capture(errors, () => enter(nextRoot, errors));
+				surfaceErrors(errors, "Focus scope entry failed");
+			}
+		}
+		recover();
+	};
+	const activate = () => {
+		assertAlive();
+		if (activeState.value) return;
+		activeState.value = true;
+		try {
+			refresh();
+		} catch (error) {
+			activeState.value = false;
+			detachDom();
+			throw error;
+		}
+	};
+	const deactivate = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		const errors = [];
+		const scopeRoot = token.root;
+		const document = token.document;
+		const active = document ? deepActiveElement(document) : null;
+		const closingRoots = rootsOwnedBy(token);
+		let shouldRestore = false;
+		capture(errors, () => {
+			const contain = readBoolean(options.contain, "contain");
+			shouldRestore = readBoolean(options.restoreFocus, "restoreFocus") && (!scopeRoot || contain || containsComposed(scopeRoot, active) || !scopeRoot.isConnected && active === document?.body);
+		});
+		const parent = parentScope(token);
+		detachDom();
+		activeState.value = false;
+		if (shouldRestore) {
+			let target = null;
+			capture(errors, () => {
+				target = readTarget(options.restoreTarget?.(), "restoreTarget") ?? capturedTarget;
+			});
+			if (!isUsableTarget(target)) {
+				const usableOutside = (candidate) => isUsableTarget(candidate) && !closingRoots.some((closingRoot) => containsComposed(closingRoot, candidate));
+				const after = restoreCandidates.slice(restoreIndex + 1).find(usableOutside);
+				const before = restoreCandidates.slice(0, Math.max(0, restoreIndex)).reverse().find(usableOutside);
+				const parentTarget = parent?.lastFocused ?? null;
+				target = after ?? before ?? (isUsableTarget(parentTarget) ? parentTarget : null);
+			}
+			const event = createAutoFocusEvent("unmount", target);
+			capture(errors, () => options.onUnmountAutoFocus?.(event));
+			const restoreDestination = target;
+			if (!event.defaultPrevented && isUsableTarget(restoreDestination)) capture(errors, () => focusElement(restoreDestination));
+		}
+		capturedTarget = null;
+		restoreCandidates = [];
+		restoreIndex = -1;
+		restorationCaptured = false;
+		entryHandled = false;
+		token.lastFocused = null;
+		surfaceErrors(errors, "Focus scope restoration failed");
+	};
+	const stopRootWatch = watch(() => toValue(options.root), () => {
+		if (activeState.value) refresh();
+	}, { flush: "sync" });
+	return Object.freeze({
+		...manager,
+		isActive: shallowReadonly(activeState),
+		activate,
+		deactivate,
+		refresh,
+		dispose: () => {
+			if (disposed) return;
+			try {
+				deactivate();
+			} finally {
+				disposed = true;
+				stopRootWatch();
+				detachDom();
+			}
+		}
+	});
+}
+//#endregion
+export { useFocusScope as n, createFocusScope as t };

package/dist/focus-scope-dom-DBwNEWxG.mjs

@@ -0,0 +1,264 @@
+import { toValue } from "vue";
+//#region src/focus-scope-internal.ts
+const optionDiagnostic = "VIZE_UI_FOCUS_SCOPE_OPTION";
+const rootDiagnostic = "VIZE_UI_FOCUS_SCOPE_ROOT";
+function capture(errors, callback) {
+	try {
+		callback();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function surfaceErrors(errors, message) {
+	if (errors.length === 1) throw errors[0];
+	if (errors.length < 2) return;
+	const Aggregate = globalThis.AggregateError;
+	if (typeof Aggregate === "function") throw new Aggregate(errors, message);
+	const fallback = Object.assign(new Error(message), { errors: [...errors] });
+	fallback.name = "AggregateError";
+	throw fallback;
+}
+function readBoolean(source, name) {
+	const value = toValue(source);
+	if (value === void 0) return false;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: ${name} must resolve to a boolean`);
+	return value;
+}
+function readRoot(source) {
+	const value = toValue(source);
+	if (value === void 0 || value === null) return null;
+	const candidate = value;
+	if (candidate.nodeType !== 1 || !candidate.ownerDocument) throw new TypeError(`${rootDiagnostic}: root must resolve to an Element or null`);
+	return value;
+}
+function readTarget(value, name) {
+	if (value === void 0 || value === null) return null;
+	const candidate = value;
+	if (candidate.nodeType !== 1 || candidate.namespaceURI !== "http://www.w3.org/1999/xhtml" || typeof candidate.focus !== "function") throw new TypeError(`${optionDiagnostic}: ${name} must resolve to an HTMLElement or null`);
+	return value;
+}
+function validateOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${optionDiagnostic}: options must be an object`);
+	readRoot(options.root);
+	readBoolean(options.contain, "contain");
+	readBoolean(options.autoFocus, "autoFocus");
+	readBoolean(options.restoreFocus, "restoreFocus");
+	for (const name of [
+		"initialFocus",
+		"restoreTarget",
+		"fallbackFocus",
+		"accept",
+		"onMountAutoFocus",
+		"onUnmountAutoFocus"
+	]) if (options[name] !== void 0 && typeof options[name] !== "function") throw new TypeError(`${optionDiagnostic}: ${name} must be a function`);
+}
+function resolveMoveOptions(value) {
+	const options = value ?? {};
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${optionDiagnostic}: focus movement options must be an object`);
+	for (const name of [
+		"includeProgrammatic",
+		"preventScroll",
+		"wrap"
+	]) {
+		const current = options[name];
+		if (current !== void 0 && typeof current !== "boolean") throw new TypeError(`${optionDiagnostic}: ${name} must be a boolean`);
+	}
+	if (options.accept !== void 0 && typeof options.accept !== "function") throw new TypeError(`${optionDiagnostic}: accept must be a function`);
+	return {
+		...options,
+		includeProgrammatic: options.includeProgrammatic ?? false,
+		preventScroll: options.preventScroll ?? true,
+		wrap: options.wrap ?? false
+	};
+}
+/** Order positive tabindex values first and ascending, leaving ties to the caller. */
+function comparePositiveTabindex(left, right) {
+	const leftPositive = left.tabIndex > 0;
+	const rightPositive = right.tabIndex > 0;
+	if (leftPositive && rightPositive) return left.tabIndex - right.tabIndex;
+	if (leftPositive !== rightPositive) return leftPositive ? -1 : 1;
+	return 0;
+}
+function documentOrder(elements) {
+	const unique = [...new Set(elements)];
+	const order = new Map(unique.map((element, index) => [element, index]));
+	return unique.sort((left, right) => {
+		const precedence = comparePositiveTabindex(left, right);
+		if (precedence !== 0) return precedence;
+		const position = left.compareDocumentPosition(right);
+		if (position & 1) return (order.get(left) ?? 0) - (order.get(right) ?? 0);
+		return position & 4 ? -1 : 1;
+	});
+}
+//#endregion
+//#region src/focus-scope-dom.ts
+const focusableSelector = [
+	"a[href]",
+	"area[href]",
+	"audio[controls]",
+	"button",
+	"embed",
+	"iframe",
+	"input",
+	"object",
+	"select",
+	"summary",
+	"textarea",
+	"video[controls]",
+	"[contenteditable]",
+	"[tabindex]"
+].join(",");
+function composedParent(element) {
+	if (element.assignedSlot) return element.assignedSlot;
+	if (element.parentElement) return element.parentElement;
+	return element.getRootNode().host ?? null;
+}
+function containsComposed(root, element) {
+	let current = element;
+	while (current) {
+		if (root === current || root.contains(current)) return true;
+		current = composedParent(current);
+	}
+	return false;
+}
+function deepActiveElement(document) {
+	let active = document.activeElement;
+	while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+	return active;
+}
+function isHidden(element, boundary, checkComputedStyle, computedHidden = /* @__PURE__ */ new Map()) {
+	let current = element;
+	while (current) {
+		const html = current;
+		if (html.hidden || html.getAttribute("aria-hidden") === "true" || html.hasAttribute("inert") || html.inert === true) return true;
+		if (html.localName === "details" && !html.hasAttribute("open")) {
+			const summary = Array.from(html.children).find(({ localName }) => localName === "summary");
+			if (!summary || summary !== element && !summary.contains(element)) return true;
+		}
+		if (html.style.display === "none" || html.style.visibility === "hidden" || html.style.visibility === "collapse") return true;
+		if (checkComputedStyle) {
+			let hidden = computedHidden.get(current);
+			if (hidden === void 0) {
+				const style = html.ownerDocument.defaultView?.getComputedStyle(html);
+				hidden = style?.display === "none" || style?.visibility === "hidden" || style?.visibility === "collapse";
+				computedHidden.set(current, hidden);
+			}
+			if (hidden) return true;
+		}
+		if (current === boundary) break;
+		current = composedParent(current);
+	}
+	return false;
+}
+function hasStyleSheets(element) {
+	return [element.ownerDocument, element.getRootNode()].some((scope) => (scope.styleSheets?.length ?? 0) + (scope.adoptedStyleSheets?.length ?? 0) > 0);
+}
+function isDisabled(element) {
+	if (element.disabled === true) return true;
+	let current = element.parentElement;
+	while (current) {
+		const html = current;
+		if ((html.localName === "optgroup" || html.localName === "select") && html.disabled === true) return true;
+		if (html.localName === "fieldset" && html.disabled === true) {
+			const firstLegend = Array.from(html.children).find(({ localName }) => localName === "legend");
+			if (!firstLegend || firstLegend !== element && !firstLegend.contains(element)) return true;
+		}
+		current = current.parentElement;
+	}
+	return false;
+}
+function isNativeFocusable(element) {
+	const name = element.localName;
+	if (name === "input") return element.type !== "hidden";
+	if (name === "a" || name === "area") return element.hasAttribute("href");
+	if (name === "audio" || name === "video") return element.hasAttribute("controls");
+	if (name === "button" || name === "embed" || name === "iframe" || name === "object" || name === "select" || name === "textarea") return true;
+	if (name === "summary") {
+		const details = element.parentElement;
+		return details?.localName === "details" && Array.from(details.children).find(({ localName }) => localName === "summary") === element;
+	}
+	const contenteditable = element.getAttribute("contenteditable");
+	return element.isContentEditable || contenteditable === "" || contenteditable === "true" || contenteditable === "plaintext-only";
+}
+function isProgrammaticallyFocusable(element) {
+	if (element.localName === "input" && element.type.toLowerCase() === "hidden") return false;
+	return element.matches(focusableSelector) && (element.hasAttribute("tabindex") || isNativeFocusable(element));
+}
+function isRadioTabbable(element, candidates) {
+	if (element.localName !== "input" || element.type !== "radio") return true;
+	const radio = element;
+	if (!radio.name || radio.checked) return true;
+	const group = candidates.filter((candidate) => {
+		const input = candidate;
+		return candidate.localName === "input" && input.type === "radio" && input.name === radio.name && input.form === radio.form && candidate.getRootNode() === radio.getRootNode();
+	});
+	return !group.some(({ checked }) => checked) && group[0] === radio;
+}
+function collectElements(root) {
+	const elements = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visitElement = (element) => {
+		if (seen.has(element)) return;
+		seen.add(element);
+		if (element.namespaceURI === "http://www.w3.org/1999/xhtml" && typeof element.focus === "function") elements.push(element);
+		const slot = element;
+		if (slot.localName === "slot" && typeof slot.assignedElements === "function") {
+			const assigned = slot.assignedElements({ flatten: true });
+			if (assigned.length > 0) {
+				for (const child of assigned) visitElement(child);
+				return;
+			}
+		}
+		const children = element.shadowRoot?.children ?? element.children;
+		for (const child of children) visitElement(child);
+	};
+	const children = root.shadowRoot?.children ?? root.children;
+	for (const child of children) visitElement(child);
+	return elements;
+}
+function focusableElements(root, options = {}) {
+	const document = root.ownerDocument;
+	const checkComputedStyle = hasStyleSheets(root);
+	const visibilityBoundary = document.documentElement ?? root;
+	const computedHidden = /* @__PURE__ */ new Map();
+	const candidates = collectElements(root).filter((element) => {
+		if (!isProgrammaticallyFocusable(element) || isDisabled(element) || isHidden(element, visibilityBoundary, checkComputedStyle, computedHidden)) return false;
+		const tabindex = element.getAttribute("tabindex");
+		const explicit = tabindex !== null && Number(tabindex) >= 0;
+		const native = isNativeFocusable(element);
+		const programmatic = tabindex !== null || native;
+		const sequential = tabindex === null ? native || element.tabIndex >= 0 : explicit;
+		return (options.includeProgrammatic ? programmatic : sequential) && options.accept?.(element) !== false;
+	});
+	return candidates.filter((element) => options.includeProgrammatic ? true : isRadioTabbable(element, candidates)).map((element, order) => ({
+		element,
+		order
+	})).sort((left, right) => comparePositiveTabindex(left.element, right.element) || left.order - right.order).map(({ element }) => element);
+}
+function focusElement(element, preventScroll = true) {
+	try {
+		element.focus({ preventScroll });
+	} catch {
+		element.focus();
+	}
+}
+function isUsableTarget(element) {
+	if (element?.isConnected !== true || element.nodeType !== 1 || element.namespaceURI !== "http://www.w3.org/1999/xhtml" || !isProgrammaticallyFocusable(element) || isDisabled(element)) return false;
+	const boundary = element.ownerDocument.documentElement;
+	return !boundary || !isHidden(element, boundary, hasStyleSheets(element));
+}
+function createAutoFocusEvent(type, target) {
+	let prevented = false;
+	return Object.freeze({
+		type,
+		target,
+		get defaultPrevented() {
+			return prevented;
+		},
+		preventDefault: () => {
+			prevented = true;
+		}
+	});
+}
+//#endregion
+export { focusableElements as a, documentOrder as c, readTarget as d, resolveMoveOptions as f, focusElement as i, readBoolean as l, validateOptions as m, createAutoFocusEvent as n, isUsableTarget as o, surfaceErrors as p, deepActiveElement as r, capture as s, containsComposed as t, readRoot as u };

package/dist/focus-scope.d.mts

@@ -0,0 +1,2 @@
+import { a as FocusScopeManager, i as FocusScopeController, n as useFocusScope, o as FocusScopeMoveOptions, r as FocusScopeAutoFocusEvent, s as FocusScopeOptions, t as createFocusScope } from "./focus-scope-CavhKWx0.mjs";
+export { type FocusScopeAutoFocusEvent, type FocusScopeController, type FocusScopeManager, type FocusScopeMoveOptions, type FocusScopeOptions, createFocusScope, useFocusScope };

package/dist/focus-scope.mjs

@@ -0,0 +1,2 @@
+import { n as useFocusScope, t as createFocusScope } from "./focus-scope-D9U1aj67.mjs";
+export { createFocusScope, useFocusScope };

package/dist/focus.d.mts

@@ -0,0 +1,2 @@
+import { a as useFocusRing, c as FocusController, d as FocusOptions, f as FocusProps, h as FocusWithinOptions, i as useFocus, l as FocusEvent, m as FocusRingOptions, n as createFocusRing, o as useFocusWithin, p as FocusRingController, r as createFocusWithin, s as FocusChangeReason, t as createFocus, u as FocusMode } from "./focus-K6dOifoZ.mjs";
+export { type FocusChangeReason, type FocusController, type FocusEvent, type FocusMode, type FocusOptions, type FocusProps, type FocusRingController, type FocusRingOptions, type FocusWithinOptions, createFocus, createFocusRing, createFocusWithin, useFocus, useFocusRing, useFocusWithin };

package/dist/focus.mjs

@@ -0,0 +1,2 @@
+import { a as useFocusRing, i as useFocus, n as createFocusRing, o as useFocusWithin, r as createFocusWithin, t as createFocus } from "./focus-CAWi_I-0.mjs";
+export { createFocus, createFocusRing, createFocusWithin, useFocus, useFocusRing, useFocusWithin };