@vizejs/ui 0.345.0 → 0.350.2

package/dist/inert-outside-CyqtoKQ4.mjs

@@ -0,0 +1,346 @@
+import { getCurrentInstance, getCurrentScope, onMounted, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/inert-outside-internal.ts
+const optionDiagnostic = "VIZE_UI_INERT_OUTSIDE_OPTION";
+const rootDiagnostic = "VIZE_UI_INERT_OUTSIDE_ROOT";
+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 readBranches(source, document) {
+	const value = toValue(source) ?? [];
+	if (!Array.isArray(value)) throw new TypeError(`${optionDiagnostic}: branches must resolve to an array of Elements`);
+	const unique = [...new Set(value)];
+	for (const branch of unique) {
+		const candidate = branch;
+		if (candidate.nodeType !== 1 || !candidate.ownerDocument) throw new TypeError(`${optionDiagnostic}: branches must contain only Elements`);
+		if (document && candidate.ownerDocument !== document) throw new TypeError(`${optionDiagnostic}: branches must share the root document`);
+	}
+	return unique;
+}
+function readEnabled(source) {
+	const value = toValue(source);
+	if (value === void 0) return true;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: enabled must resolve to a boolean`);
+	return value;
+}
+function readMode(source) {
+	const value = toValue(source) ?? "both";
+	if (value !== "aria-hidden" && value !== "both" && value !== "inert") throw new TypeError(`${optionDiagnostic}: mode must resolve to "aria-hidden", "both", or "inert"`);
+	return value;
+}
+function validateOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${optionDiagnostic}: options must be an object`);
+	const root = readRoot(options.root);
+	readBranches(options.branches, root?.ownerDocument ?? null);
+	readEnabled(options.enabled);
+	readMode(options.mode);
+}
+//#endregion
+//#region src/inert-outside-dom.ts
+const ignoredNames = new Set([
+	"link",
+	"meta",
+	"noscript",
+	"script",
+	"style",
+	"template"
+]);
+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 (current === root || root.contains(current)) return true;
+		current = composedParent(current);
+	}
+	return false;
+}
+function renderedChildren(element) {
+	const slot = element;
+	if (slot.localName === "slot" && typeof slot.assignedElements === "function") {
+		const assigned = slot.assignedElements({ flatten: true });
+		if (assigned.length > 0) return assigned;
+	}
+	return Array.from(element.shadowRoot?.children ?? element.children);
+}
+/** Collect every currently reachable open shadow root for document-level observation. */
+function collectOpenShadowRoots(root) {
+	const roots = [];
+	for (const element of root.querySelectorAll("*")) {
+		const shadowRoot = element.shadowRoot;
+		if (!shadowRoot) continue;
+		roots.push(shadowRoot, ...collectOpenShadowRoots(shadowRoot));
+	}
+	return roots;
+}
+function isInsideAllowed(element, allowed) {
+	return allowed.some((root) => root === element || containsComposed(root, element));
+}
+function containsAllowed(element, allowed) {
+	return allowed.some((root) => root === element || containsComposed(element, root));
+}
+/** Find the smallest rendered sibling subtrees outside every allowed root. */
+function collectOutside(document, allowed) {
+	const body = document.body;
+	if (!body || allowed.some((root) => root === body || containsComposed(root, body))) return [];
+	const outside = [];
+	const visit = (container) => {
+		for (const child of renderedChildren(container)) {
+			if (ignoredNames.has(child.localName)) continue;
+			if (isInsideAllowed(child, allowed)) continue;
+			if (containsAllowed(child, allowed)) visit(child);
+			else outside.push(child);
+		}
+	};
+	visit(body);
+	return outside;
+}
+function maskFor(mode) {
+	return {
+		ariaHidden: mode === "aria-hidden" || mode === "both",
+		inert: mode === "inert" || mode === "both"
+	};
+}
+//#endregion
+//#region src/inert-outside-stack.ts
+const states = /* @__PURE__ */ new WeakMap();
+const observationOptions = Object.freeze({
+	attributes: true,
+	attributeFilter: [
+		"aria-hidden",
+		"inert",
+		"name",
+		"slot"
+	],
+	childList: true,
+	subtree: true
+});
+function stateFor(document) {
+	let state = states.get(document);
+	if (!state) {
+		state = {
+			document,
+			managed: /* @__PURE__ */ new Map(),
+			observer: null,
+			queued: false,
+			tokens: []
+		};
+		states.set(document, state);
+	}
+	return state;
+}
+function restore(state) {
+	for (const [element, snapshot] of state.managed) {
+		if (snapshot.ariaHidden === null) element.removeAttribute("aria-hidden");
+		else element.setAttribute("aria-hidden", snapshot.ariaHidden);
+		if (snapshot.inert) element.setAttribute("inert", "");
+		else element.removeAttribute("inert");
+	}
+	state.managed.clear();
+}
+function mergeMask(current, next) {
+	return {
+		ariaHidden: current?.ariaHidden === true || next.ariaHidden,
+		inert: current?.inert === true || next.inert
+	};
+}
+function refreshObservationRoots(state) {
+	const root = state.document.documentElement;
+	if (!state.observer || !root) return;
+	state.observer.disconnect();
+	state.observer.observe(root, observationOptions);
+	for (const shadowRoot of collectOpenShadowRoots(state.document)) state.observer.observe(shadowRoot, observationOptions);
+}
+function connectedRoots(token) {
+	if (!token.root?.isConnected || !token.readEnabled()) return [];
+	return [...new Set([token.root, ...token.readBranches()])].filter((root) => root.isConnected);
+}
+function recomputeDocument(state) {
+	const records = state.tokens.map((token) => ({
+		mode: token.readMode(),
+		roots: connectedRoots(token),
+		token
+	})).filter(({ roots }) => roots.length > 0);
+	const desired = /* @__PURE__ */ new Map();
+	for (let index = 0; index < records.length; index++) {
+		const record = records[index];
+		if (!record) continue;
+		const allowed = records.slice(index).flatMap(({ roots }) => roots);
+		const affected = collectOutside(state.document, allowed);
+		record.token.setAffected(Object.freeze(affected));
+		const mask = maskFor(record.mode);
+		for (const element of affected) desired.set(element, mergeMask(desired.get(element), mask));
+	}
+	for (const token of state.tokens) if (!records.some((record) => record.token === token)) token.setAffected(Object.freeze([]));
+	restore(state);
+	for (const [element, mask] of desired) {
+		state.managed.set(element, {
+			ariaHidden: element.getAttribute("aria-hidden"),
+			inert: element.hasAttribute("inert")
+		});
+		if (mask.ariaHidden) element.setAttribute("aria-hidden", "true");
+		if (mask.inert) element.setAttribute("inert", "");
+	}
+	state.observer?.takeRecords();
+	refreshObservationRoots(state);
+}
+function observe(state) {
+	if (state.observer) return;
+	const Observer = state.document.defaultView?.MutationObserver;
+	const root = state.document.documentElement;
+	if (!Observer || !root) return;
+	state.observer = new Observer(() => {
+		if (state.queued) return;
+		state.queued = true;
+		queueMicrotask(() => {
+			state.queued = false;
+			if (state.tokens.length > 0) recomputeDocument(state);
+		});
+	});
+	refreshObservationRoots(state);
+}
+function attachToken(token, root) {
+	if (token.document === root.ownerDocument) {
+		token.root = root;
+		recomputeDocument(stateFor(root.ownerDocument));
+		return;
+	}
+	detachToken(token);
+	token.document = root.ownerDocument;
+	token.root = root;
+	const state = stateFor(root.ownerDocument);
+	state.tokens.push(token);
+	observe(state);
+	recomputeDocument(state);
+}
+function detachToken(token) {
+	const document = token.document;
+	if (!document) {
+		token.root = null;
+		token.setAffected(Object.freeze([]));
+		return;
+	}
+	const state = stateFor(document);
+	const index = state.tokens.indexOf(token);
+	if (index >= 0) state.tokens.splice(index, 1);
+	token.document = null;
+	token.root = null;
+	token.setAffected(Object.freeze([]));
+	if (state.tokens.length === 0) {
+		state.observer?.disconnect();
+		state.observer = null;
+		restore(state);
+		states.delete(document);
+	} else recomputeDocument(state);
+}
+function refreshToken(token) {
+	if (token.document) recomputeDocument(stateFor(token.document));
+}
+//#endregion
+//#region src/inert-outside.ts
+const disposedDiagnostic = "VIZE_UI_INERT_OUTSIDE_DISPOSED";
+const setupDiagnostic = "VIZE_UI_INERT_OUTSIDE_SETUP";
+/** Isolate rendered content outside reactive allowed roots without owning visual styling. */
+function createInertOutside(options) {
+	validateOptions(options);
+	const activeState = shallowRef(false);
+	const affectedState = shallowRef(Object.freeze([]));
+	const token = {
+		document: null,
+		root: null,
+		readBranches: () => readBranches(options.branches, token.document),
+		readEnabled: () => readEnabled(options.enabled),
+		readMode: () => readMode(options.mode),
+		setAffected: (elements) => {
+			affectedState.value = elements;
+		}
+	};
+	let disposed = false;
+	const assertAlive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const refresh = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		const nextRoot = readRoot(options.root);
+		if (nextRoot !== token.root) if (nextRoot) {
+			readBranches(options.branches, nextRoot.ownerDocument);
+			readEnabled(options.enabled);
+			readMode(options.mode);
+			attachToken(token, nextRoot);
+		} else detachToken(token);
+		else {
+			readBranches(options.branches, token.document);
+			readEnabled(options.enabled);
+			readMode(options.mode);
+			refreshToken(token);
+		}
+	};
+	const activate = () => {
+		assertAlive();
+		if (activeState.value) return;
+		activeState.value = true;
+		try {
+			refresh();
+		} catch (error) {
+			activeState.value = false;
+			detachToken(token);
+			throw error;
+		}
+	};
+	const deactivate = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		try {
+			detachToken(token);
+		} finally {
+			activeState.value = false;
+		}
+	};
+	const stopWatch = watch(() => {
+		const root = toValue(options.root);
+		const branches = toValue(options.branches) ?? [];
+		return [
+			root,
+			Array.isArray(branches) ? [...branches] : branches,
+			toValue(options.enabled),
+			toValue(options.mode)
+		];
+	}, () => {
+		if (activeState.value) refresh();
+	}, { flush: "sync" });
+	return Object.freeze({
+		isActive: shallowReadonly(activeState),
+		affectedElements: shallowReadonly(affectedState),
+		activate,
+		deactivate,
+		refresh,
+		dispose: () => {
+			if (disposed) return;
+			try {
+				detachToken(token);
+			} finally {
+				activeState.value = false;
+				disposed = true;
+				stopWatch();
+			}
+		}
+	});
+}
+/** Create, mount-activate, and scope-dispose an outside-inerting controller. */
+function useInertOutside(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createInertOutside(options);
+	if (getCurrentInstance()) onMounted(controller.activate);
+	else controller.activate();
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useInertOutside as n, createInertOutside as t };

package/dist/inert-outside-tuHRmaqJ.d.mts

@@ -0,0 +1,43 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/inert-outside-types.d.ts
+/** Attribute strategy used to isolate content outside an allowed subtree. */
+type InertOutsideMode = "aria-hidden" | "both" | "inert";
+/** Reactive configuration for one document-level inerting layer. */
+interface InertOutsideOptions {
+  /** Primary allowed root. It may be `null` during SSR and before mount. */
+  readonly root: MaybeRefOrGetter<Element | null | undefined>;
+  /** Additional portalled or exceptional roots that remain available. */
+  readonly branches?: MaybeRefOrGetter<readonly Element[] | undefined>;
+  /** Whether an activated controller currently isolates outside content. @default true */
+  readonly enabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Isolation attributes to apply. `aria-hidden` alone does not prevent focus or pointer input;
+   * reserve that mode for integrations that provide equivalent interaction blocking separately.
+   * @default "both"
+   */
+  readonly mode?: MaybeRefOrGetter<InertOutsideMode | undefined>;
+}
+/** Lifecycle and inspection interface returned by `createInertOutside`. */
+interface InertOutsideController {
+  /** Whether this controller is activated, independently of reactive enablement. */
+  readonly isActive: Readonly<ShallowRef<boolean>>;
+  /** Elements selected by this layer during the latest recomputation. */
+  readonly affectedElements: Readonly<ShallowRef<readonly Element[]>>;
+  /** Join the document isolation stack. Safe to call repeatedly. */
+  readonly activate: () => void;
+  /** Leave the stack and restore every attribute owned by this layer. */
+  readonly deactivate: () => void;
+  /** Re-read roots and options after imperative DOM movement. */
+  readonly refresh: () => void;
+  /** Permanently release reactive and document-level ownership. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/inert-outside.d.ts
+/** Isolate rendered content outside reactive allowed roots without owning visual styling. */
+declare function createInertOutside(options: InertOutsideOptions): InertOutsideController;
+/** Create, mount-activate, and scope-dispose an outside-inerting controller. */
+declare function useInertOutside(options: InertOutsideOptions): InertOutsideController;
+//#endregion
+export { InertOutsideOptions as a, InertOutsideMode as i, useInertOutside as n, InertOutsideController as r, createInertOutside as t };

package/dist/inert-outside.d.mts

@@ -0,0 +1,2 @@
+import { a as InertOutsideOptions, i as InertOutsideMode, n as useInertOutside, r as InertOutsideController, t as createInertOutside } from "./inert-outside-tuHRmaqJ.mjs";
+export { type InertOutsideController, type InertOutsideMode, type InertOutsideOptions, createInertOutside, useInertOutside };

package/dist/inert-outside.mjs

@@ -0,0 +1,2 @@
+import { n as useInertOutside, t as createInertOutside } from "./inert-outside-CyqtoKQ4.mjs";
+export { createInertOutside, useInertOutside };

package/dist/interaction-modality-DOZK0BpZ.mjs

@@ -0,0 +1,304 @@
+import { computed, getCurrentScope, isRef, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/interaction-modality-events.ts
+const modifierKeys = new Set([
+	"Alt",
+	"AltGraph",
+	"Control",
+	"Meta"
+]);
+/** Classify keyboard intent while excluding composition and modified shortcuts. */
+function classifyKeyboardEvent(event) {
+	if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey || modifierKeys.has(event.key)) return null;
+	return {
+		modality: "keyboard",
+		reason: "keyboard",
+		originalEvent: event
+	};
+}
+/** Map pointer hardware into the stable public modality vocabulary. */
+function classifyPointerEvent(event) {
+	if (event.pointerId === -1 && event.pointerType === "") return {
+		modality: "virtual",
+		reason: "virtual",
+		originalEvent: event
+	};
+	const modality = event.pointerType === "touch" ? "touch" : "pointer";
+	return {
+		modality,
+		reason: modality,
+		originalEvent: event
+	};
+}
+/** Classify coordinate-free clicks used by keyboards and assistive technology. */
+function classifyVirtualClick(event, current) {
+	if (event.detail !== 0 || current === "keyboard") return null;
+	return {
+		modality: "virtual",
+		reason: "virtual",
+		originalEvent: event
+	};
+}
+//#endregion
+//#region src/interaction-modality-hub.ts
+const hubs = /* @__PURE__ */ new WeakMap();
+/** Install one capture listener set for all consumers in a document. */
+function createHub(document, initialModality) {
+	const subscribers = /* @__PURE__ */ new Set();
+	const pendingUpdates = [];
+	let publishing = false;
+	const hub = {
+		subscribers,
+		modality: initialModality,
+		disposeListeners: () => void 0,
+		publish: () => false
+	};
+	hub.publish = (update) => {
+		if (hub.modality === update.modality && pendingUpdates.length === 0) return false;
+		pendingUpdates.push(update);
+		if (publishing) return true;
+		publishing = true;
+		const errors = [];
+		try {
+			while (pendingUpdates.length > 0) {
+				const nextUpdate = pendingUpdates.shift();
+				if (hub.modality === nextUpdate.modality) continue;
+				hub.modality = nextUpdate.modality;
+				for (const subscriber of Array.from(subscribers)) {
+					if (!subscribers.has(subscriber)) continue;
+					try {
+						subscriber(nextUpdate);
+					} catch (error) {
+						errors.push(error);
+					}
+				}
+			}
+		} finally {
+			publishing = false;
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Interaction modality subscribers failed");
+		return true;
+	};
+	let lastTouchTime = Number.NEGATIVE_INFINITY;
+	const onKeyDown = (event) => {
+		const update = classifyKeyboardEvent(event);
+		if (update) hub.publish(update);
+	};
+	const onPointerDown = (event) => hub.publish(classifyPointerEvent(event));
+	const onMouseDown = (event) => {
+		const elapsedSinceTouch = event.timeStamp - lastTouchTime;
+		if (elapsedSinceTouch >= 0 && elapsedSinceTouch < 800) return;
+		hub.publish({
+			modality: "pointer",
+			reason: "pointer",
+			originalEvent: event
+		});
+	};
+	const onTouchStart = (event) => {
+		lastTouchTime = event.timeStamp;
+		hub.publish({
+			modality: "touch",
+			reason: "touch",
+			originalEvent: event
+		});
+	};
+	const onClick = (event) => {
+		const update = classifyVirtualClick(event, hub.modality);
+		if (update) hub.publish(update);
+	};
+	document.addEventListener("keydown", onKeyDown, true);
+	document.addEventListener("click", onClick, true);
+	const supportsPointerEvents = Boolean(document.defaultView?.PointerEvent);
+	if (supportsPointerEvents) document.addEventListener("pointerdown", onPointerDown, true);
+	else {
+		document.addEventListener("mousedown", onMouseDown, true);
+		document.addEventListener("touchstart", onTouchStart, true);
+	}
+	hub.disposeListeners = () => {
+		document.removeEventListener("keydown", onKeyDown, true);
+		document.removeEventListener("click", onClick, true);
+		if (supportsPointerEvents) document.removeEventListener("pointerdown", onPointerDown, true);
+		else {
+			document.removeEventListener("mousedown", onMouseDown, true);
+			document.removeEventListener("touchstart", onTouchStart, true);
+		}
+	};
+	return hub;
+}
+/** Subscribe to shared document state and return an idempotent release callback. */
+function subscribeToDocumentModality(document, initialModality, subscriber) {
+	let hub = hubs.get(document);
+	if (!hub) {
+		hub = createHub(document, initialModality);
+		hubs.set(document, hub);
+	}
+	hub.subscribers.add(subscriber);
+	let released = false;
+	return {
+		current: hub.modality,
+		release: () => {
+			if (released) return;
+			released = true;
+			hub?.subscribers.delete(subscriber);
+			if (hub?.subscribers.size === 0) {
+				hub.disposeListeners();
+				hubs.delete(document);
+			}
+		}
+	};
+}
+/** Synchronize an explicit consumer update with every peer in a document. */
+function publishDocumentModality(document, update) {
+	return hubs.get(document)?.publish(update) ?? false;
+}
+//#endregion
+//#region src/interaction-modality.ts
+const disposedDiagnostic = "VIZE_UI_INTERACTION_MODALITY_DISPOSED";
+const invalidDocumentDiagnostic = "VIZE_UI_INTERACTION_MODALITY_DOCUMENT";
+const setupDiagnostic = "VIZE_UI_INTERACTION_MODALITY_SETUP";
+const invalidValueDiagnostic = "VIZE_UI_INTERACTION_MODALITY_VALUE";
+const modalities = new Set([
+	"keyboard",
+	"pointer",
+	"touch",
+	"virtual"
+]);
+function defaultDocument() {
+	return typeof globalThis.document === "undefined" ? null : globalThis.document;
+}
+/** Accept cross-realm documents without relying on an unreliable instanceof check. */
+function toDocument(value) {
+	if (value == null) return null;
+	if (value.nodeType !== 9 || typeof value.addEventListener !== "function" || typeof value.removeEventListener !== "function") throw new TypeError(`${invalidDocumentDiagnostic}: expected a Document, null, or undefined`);
+	return value;
+}
+/** Validate JavaScript callers without widening the closed TypeScript union. */
+function toModality(value) {
+	if (value === null || modalities.has(value)) return value;
+	throw new TypeError(`${invalidValueDiagnostic}: expected keyboard, pointer, touch, virtual, or null`);
+}
+/**
+* Create an SSR-safe, document-scoped interaction-modality observer.
+*
+* Trackers in one document share native capture listeners and state. Separate
+* documents, including iframes, remain isolated. Call {@link InteractionModalityTracker.dispose}
+* when using this factory outside a Vue effect scope.
+*/
+function createInteractionModalityTracker(options = {}) {
+	const ownerDocument = shallowRef(null);
+	const modality = shallowRef(toModality(options.initialModality ?? null));
+	let releaseDocument = null;
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the tracker has been disposed`);
+	};
+	const apply = (update) => {
+		if (modality.value === update.modality) return false;
+		const previousModality = modality.value;
+		modality.value = update.modality;
+		const change = Object.freeze({
+			modality: update.modality,
+			previousModality,
+			reason: update.reason,
+			originalEvent: update.originalEvent,
+			document: ownerDocument.value
+		});
+		options.onChange?.(change);
+		return true;
+	};
+	const releaseCurrentDocument = () => {
+		const changed = ownerDocument.value !== null;
+		releaseDocument?.();
+		releaseDocument = null;
+		ownerDocument.value = null;
+		return changed;
+	};
+	const attach = (nextDocument) => {
+		assertActive();
+		const resolved = toDocument(nextDocument);
+		if (ownerDocument.value === resolved) return false;
+		releaseCurrentDocument();
+		if (!resolved) return true;
+		ownerDocument.value = resolved;
+		try {
+			const subscription = subscribeToDocumentModality(resolved, modality.value, apply);
+			releaseDocument = subscription.release;
+			if (subscription.current !== modality.value) apply({
+				modality: subscription.current,
+				reason: "document",
+				originalEvent: null
+			});
+		} catch (error) {
+			releaseCurrentDocument();
+			throw error;
+		}
+		return true;
+	};
+	const detach = () => {
+		assertActive();
+		return releaseCurrentDocument();
+	};
+	const setModality = (nextModality) => {
+		assertActive();
+		const update = {
+			modality: toModality(nextModality),
+			reason: "manual",
+			originalEvent: null
+		};
+		if (ownerDocument.value) return publishDocumentModality(ownerDocument.value, update);
+		return apply(update);
+	};
+	let stopDocumentWatch = () => void 0;
+	if (options.document === void 0) attach(defaultDocument());
+	else if (isRef(options.document) || typeof options.document === "function") stopDocumentWatch = watch(() => toValue(options.document), (nextDocument) => attach(toDocument(nextDocument)), {
+		flush: "sync",
+		immediate: true
+	});
+	else attach(toDocument(options.document));
+	const dispose = () => {
+		if (disposed) return;
+		stopDocumentWatch();
+		releaseCurrentDocument();
+		disposed = true;
+	};
+	return Object.freeze({
+		document: shallowReadonly(ownerDocument),
+		modality: shallowReadonly(modality),
+		isFocusVisible: computed(() => modality.value === "keyboard" || modality.value === "virtual"),
+		attach,
+		detach,
+		setModality,
+		dispose
+	});
+}
+/**
+* Create a tracker owned by the current Vue effect scope.
+*
+* The tracker is disposed automatically when its component or effect scope is
+* destroyed, preventing document-listener leaks.
+*/
+function useInteractionModality(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const tracker = createInteractionModalityTracker(options);
+	onScopeDispose(tracker.dispose);
+	return tracker;
+}
+/**
+* Determine whether a focused element should expose its focus indicator.
+*
+* Native `:focus-visible` semantics take precedence. The modality fallback is
+* used only when the selector is unsupported, preserving text-input and
+* platform heuristics implemented by the browser.
+*/
+function isElementFocusVisible(element, modality) {
+	if (!element) return false;
+	const root = element.getRootNode();
+	if ((root && "activeElement" in root ? root.activeElement : element.ownerDocument.activeElement) !== element) return false;
+	try {
+		return element.matches(":focus-visible");
+	} catch {
+		return modality === "keyboard" || modality === "virtual";
+	}
+}
+//#endregion
+export { isElementFocusVisible as n, useInteractionModality as r, createInteractionModalityTracker as t };