@vizejs/ui 0.343.0 → 0.347.7

package/dist/controllable-state.d.mts

@@ -1,2 +1,2 @@
-import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-DXsYJ3yl.mjs";
+import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-B9v6FClp.mjs";
 export { ControllableState, ControllableStateOptions, StateUpdate, useControllableState };

package/dist/id-BSgJwErt.d.mts

@@ -0,0 +1,127 @@
+import * as _$vue from "vue";
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+
+//#region src/deterministic-id.d.ts
+declare const deterministicIdBrand: unique symbol;
+/** A validated DOM identifier created or accepted by the deterministic ID system. */
+type DeterministicId = string & {
+  readonly [deterministicIdBrand]: "DeterministicId";
+};
+/** Stable request, island, or subtree seed accepted by an ID scope. */
+type DeterministicIdSeed = string | number;
+/** Options for a root deterministic ID scope. */
+interface DeterministicIdScopeOptions {
+  /**
+   * Namespace prefix used by every ID in the scope.
+   *
+   * @default "vize"
+   */
+  readonly prefix?: string;
+  /** Stable request, island, or application seed. */
+  readonly seed: DeterministicIdSeed;
+}
+/** Options for a nested deterministic ID scope. */
+interface DeterministicIdChildScopeOptions {
+  /**
+   * Namespace prefix for the child scope.
+   *
+   * @default The parent scope prefix
+   */
+  readonly prefix?: string;
+  /** Stable seed that identifies the child subtree. */
+  readonly seed: DeterministicIdSeed;
+}
+/** One request-local namespace that allocates stable, collision-resistant DOM IDs. */
+interface DeterministicIdScope {
+  /** Validated namespace prefix. */
+  readonly prefix: string;
+  /** Complete namespace shared by IDs allocated from this scope. */
+  readonly namespace: string;
+  /**
+   * Allocate the next ID during component setup.
+   *
+   * The sequence is intentionally independent from child-scope allocation so
+   * adding a nested provider cannot renumber sibling control IDs.
+   */
+  readonly nextId: (hint?: string) => DeterministicId;
+  /** Create a request-local child namespace without sharing its ID counter. */
+  readonly createChild: (options: DeterministicIdChildScopeOptions) => DeterministicIdScope;
+}
+/** Options for {@link useDeterministicId}. */
+interface DeterministicIdOptions {
+  /**
+   * Consumer-owned ID. `null` and `undefined` select the generated fallback.
+   *
+   * @default undefined
+   */
+  readonly id?: MaybeRefOrGetter<string | null | undefined>;
+  /**
+   * Human-readable role appended to a generated ID.
+   *
+   * @default "id"
+   */
+  readonly hint?: string;
+  /**
+   * Prefix used when no {@link IdProvider} is present.
+   *
+   * @default "vize"
+   */
+  readonly prefix?: string;
+}
+/**
+ * Validate and brand a consumer-owned HTML ID.
+ *
+ * HTML permits a broad character set, but forbids an empty value and ASCII
+ * whitespace. This contract additionally rejects ASCII controls. Consumers
+ * remain free to use Unicode and punctuation; CSS selectors may need
+ * `CSS.escape()` for those IDs.
+ */
+declare function toDeterministicId(value: string): DeterministicId;
+/** Append a validated semantic part to an existing DOM ID. */
+declare function deriveDeterministicId(id: string, part: string): DeterministicId;
+/** Create an isolated deterministic ID scope for an application or SSR request. */
+declare function createDeterministicIdScope(options: DeterministicIdScopeOptions): DeterministicIdScope;
+/**
+ * Allocate one stable ID for the current component instance.
+ *
+ * Generated IDs use the nearest provider scope. Without a provider, Vue's
+ * hydration-stable `useId()` sequence supplies the seed, including a safe
+ * application `idPrefix`. The generated fallback is allocated once; changing
+ * an explicit reactive ID back to `undefined` restores that same fallback.
+ */
+declare function useDeterministicId(options?: DeterministicIdOptions): ComputedRef<DeterministicId>;
+//#endregion
+//#region src/DeterministicIdProvider.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Namespace prefix for this subtree.
+   *
+   * @default The parent prefix when nested; otherwise "vize"
+   */
+  readonly prefix?: string;
+  /**
+   * Stable request, island, or subtree seed.
+   *
+   * @default Vue's SSR- and hydration-stable useId() value
+   */
+  readonly seed?: string | number;
+};
+type __VLS_Slots = {
+  default(props: {
+    readonly namespace: string;
+    readonly prefix: string;
+  }): unknown;
+};
+declare const __VLS_base: _$vue.DefineComponent<__VLS_Props, {
+  namespace: string;
+  prefix: string;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { DeterministicIdScope as a, createDeterministicIdScope as c, useDeterministicId as d, DeterministicIdOptions as i, deriveDeterministicId as l, DeterministicId as n, DeterministicIdScopeOptions as o, DeterministicIdChildScopeOptions as r, DeterministicIdSeed as s, _default as t, toDeterministicId as u };

package/dist/id-CPBdeoL3.mjs

@@ -0,0 +1,137 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { computed, defineComponent, getCurrentInstance, inject, provide, renderSlot, toValue, unref, useId } from "vue";
+//#region src/deterministic-id.ts
+const deterministicIdScopeKey = Symbol("VizeUiDeterministicIdScope");
+const safePrefix = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const safeSegment = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+/**
+* Validate and brand a consumer-owned HTML ID.
+*
+* HTML permits a broad character set, but forbids an empty value and ASCII
+* whitespace. This contract additionally rejects ASCII controls. Consumers
+* remain free to use Unicode and punctuation; CSS selectors may need
+* `CSS.escape()` for those IDs.
+*/
+function toDeterministicId(value) {
+	if (!isValidHtmlId(value)) throw new Error("VIZE_UI_ID_VALUE: an id must be non-empty and contain no ASCII whitespace or controls");
+	return value;
+}
+function isValidHtmlId(value) {
+	if (value.length === 0) return false;
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 32 || code === 127) return false;
+	}
+	return true;
+}
+/** Append a validated semantic part to an existing DOM ID. */
+function deriveDeterministicId(id, part) {
+	return toDeterministicId(`${toDeterministicId(id)}-${normalizeSegment(part, "part")}`);
+}
+/** Create an isolated deterministic ID scope for an application or SSR request. */
+function createDeterministicIdScope(options) {
+	const prefix = normalizePrefix(options.prefix ?? "vize");
+	return createScope(prefix, `${prefix}-${normalizeSeed(options.seed)}`);
+}
+/**
+* Allocate one stable ID for the current component instance.
+*
+* Generated IDs use the nearest provider scope. Without a provider, Vue's
+* hydration-stable `useId()` sequence supplies the seed, including a safe
+* application `idPrefix`. The generated fallback is allocated once; changing
+* an explicit reactive ID back to `undefined` restores that same fallback.
+*/
+function useDeterministicId(options = {}) {
+	if (getCurrentInstance() === null) throw new Error("VIZE_UI_ID_SETUP: useDeterministicId() must run during component setup");
+	const vueId = useId();
+	const scope = useOptionalDeterministicIdScope();
+	const hint = normalizeSegment(options.hint ?? "id", "hint");
+	const generated = scope?.nextId(hint) ?? toDeterministicId(`${normalizePrefix(options.prefix ?? "vize")}-${normalizeSeed(vueId)}-${hint}`);
+	return computed(() => {
+		const explicit = options.id === void 0 ? void 0 : toValue(options.id);
+		return explicit === null || explicit === void 0 ? generated : toDeterministicId(explicit);
+	});
+}
+/** @internal Provide the scope owned by `IdProvider.vue`. */
+function provideDeterministicIdScope(scope) {
+	provide(deterministicIdScopeKey, scope);
+	return scope;
+}
+/** @internal Read the nearest provider without requiring one. */
+function useOptionalDeterministicIdScope() {
+	return inject(deterministicIdScopeKey, void 0);
+}
+function createScope(prefix, namespace) {
+	let idSequence = 0;
+	let childSequence = 0;
+	return Object.freeze({
+		prefix,
+		namespace,
+		nextId: (hint = "id") => toDeterministicId(`${namespace}-${normalizeSegment(hint, "hint")}-${idSequence++}`),
+		createChild: (options) => {
+			const childPrefix = options.prefix === void 0 ? prefix : normalizePrefix(options.prefix);
+			const childSeed = normalizeSeed(options.seed);
+			const inheritedNamespace = `${namespace}-scope-${childSequence++}-${childSeed}`;
+			return createScope(childPrefix, childPrefix === prefix ? inheritedNamespace : `${childPrefix}-${inheritedNamespace}`);
+		}
+	});
+}
+function normalizePrefix(value) {
+	if (!safePrefix.test(value)) throw new Error("VIZE_UI_ID_PREFIX: a prefix must start with an ASCII letter and contain only letters, digits, _ or -");
+	return value;
+}
+function normalizeSeed(value) {
+	if (typeof value === "number") {
+		if (!Number.isSafeInteger(value) || value < 0) throw new Error("VIZE_UI_ID_SEED: a numeric seed must be a non-negative safe integer");
+		return String(value);
+	}
+	return normalizeSegment(value, "seed");
+}
+function normalizeSegment(value, role) {
+	if (!safeSegment.test(value)) throw new Error(`VIZE_UI_ID_${role.toUpperCase()}: ${role} must contain only ASCII letters, digits, _ or - and may not start with punctuation`);
+	return value;
+}
+//#endregion
+//#region src/DeterministicIdProvider.vue
+var DeterministicIdProvider_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "DeterministicIdProvider",
+	props: {
+		prefix: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		seed: {
+			type: [String, Number],
+			required: false,
+			default: () => void 0
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const vueSeed = useId();
+		const parent = useOptionalDeterministicIdScope();
+		const resolvedSeed = __props.seed ?? vueSeed;
+		const scope = parent === void 0 ? createDeterministicIdScope({
+			prefix: __props.prefix ?? "vize",
+			seed: resolvedSeed
+		}) : __props.prefix === void 0 ? parent.createChild({ seed: resolvedSeed }) : parent.createChild({
+			prefix: __props.prefix,
+			seed: resolvedSeed
+		});
+		provideDeterministicIdScope(scope);
+		const namespace = scope.namespace;
+		const resolvedPrefix = scope.prefix;
+		__expose({
+			namespace,
+			prefix: resolvedPrefix
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", {
+				namespace: unref(namespace),
+				prefix: unref(resolvedPrefix)
+			}, void 0, true);
+		};
+	}
+}), [["__scopeId", "data-v-2521c635"]]);
+//#endregion
+export { useDeterministicId as a, toDeterministicId as i, createDeterministicIdScope as n, deriveDeterministicId as r, DeterministicIdProvider_default as t };

package/dist/id.d.mts

@@ -0,0 +1,2 @@
+import { a as DeterministicIdScope, c as createDeterministicIdScope, d as useDeterministicId, i as DeterministicIdOptions, l as deriveDeterministicId, n as DeterministicId, o as DeterministicIdScopeOptions, r as DeterministicIdChildScopeOptions, s as DeterministicIdSeed, t as _default, u as toDeterministicId } from "./id-BSgJwErt.mjs";
+export { DeterministicId, DeterministicIdChildScopeOptions, DeterministicIdOptions, DeterministicIdScope, DeterministicIdScopeOptions, DeterministicIdSeed, _default as IdProvider, createDeterministicIdScope, deriveDeterministicId, toDeterministicId, useDeterministicId };

package/dist/id.mjs

@@ -0,0 +1,2 @@
+import { a as useDeterministicId, i as toDeterministicId, n as createDeterministicIdScope, r as deriveDeterministicId, t as DeterministicIdProvider_default } from "./id-CPBdeoL3.mjs";
+export { DeterministicIdProvider_default as IdProvider, createDeterministicIdScope, deriveDeterministicId, toDeterministicId, useDeterministicId };

package/dist/index.d.mts

@@ -1,7 +1,13 @@
-import { i as getButtonKeyboardAction, n as ButtonKeyboardAction, r as ButtonKeyboardPhase, t as _default } from "./button-D7sM9Xmj.mjs";
-import { n as PrimitiveElement, r as _default$2, t as PrimitiveAs } from "./primitive-BtvwikH1.mjs";
-import { n as CheckboxState, r as getCheckboxState, t as _default$1 } from "./checkbox-DkwZFC80.mjs";
-import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-DXsYJ3yl.mjs";
+import { i as getButtonKeyboardAction, n as ButtonKeyboardAction, r as ButtonKeyboardPhase, t as _default } from "./button-BMIqJ_M5.mjs";
+import { n as PrimitiveElement, r as _default$3, t as PrimitiveAs } from "./primitive-Bog8qvd8.mjs";
+import { n as CheckboxState, r as getCheckboxState, t as _default$1 } from "./checkbox-sbhaWekB.mjs";
+import { i as useControllableState, n as ControllableStateOptions, r as StateUpdate, t as ControllableState } from "./controllable-state-B9v6FClp.mjs";
+import { a as CollectionActiveChangeReason, c as CollectionItemInput, d as CollectionNavigationOptions, f as CollectionRegistration, h as CollectionTextSearchOptions, i as CollectionActiveChange, l as CollectionKey, m as CollectionRegistryOptions, n as normalizeCollectionTextValue, o as CollectionDisabledBehavior, p as CollectionRegistry, r as createCollectionRegistry, s as CollectionItem, t as extractCollectionTextValue, u as CollectionNavigationDirection } from "./collection-aHZ6Pf0e.mjs";
 import { ComponentContext, createContext } from "./context.mjs";
-import { t as _default$3 } from "./visually-hidden-BegtnMng.mjs";
-export { _default as Button, ButtonKeyboardAction, ButtonKeyboardPhase, _default$1 as Checkbox, CheckboxState, ComponentContext, ControllableState, ControllableStateOptions, _default$2 as Primitive, PrimitiveAs, PrimitiveElement, StateUpdate, _default$3 as VisuallyHidden, createContext, getButtonKeyboardAction, getCheckboxState, useControllableState };
+import { a as DeterministicIdScope, c as createDeterministicIdScope, d as useDeterministicId, i as DeterministicIdOptions, l as deriveDeterministicId, n as DeterministicId, o as DeterministicIdScopeOptions, r as DeterministicIdChildScopeOptions, s as DeterministicIdSeed, t as _default$2, u as toDeterministicId } from "./id-BSgJwErt.mjs";
+import { a as InteractionModalityChange, c as InteractionModalityTracker, i as InteractionModality, n as isElementFocusVisible, o as InteractionModalityChangeReason, r as useInteractionModality, s as InteractionModalityOptions, t as createInteractionModalityTracker } from "./interaction-modality-tee79ZBZ.mjs";
+import { a as PressOptions, i as PressKeyboardBehavior, n as PressEvent, o as PressPointerType, r as PressEventType, s as PressProps, t as PressController } from "./press-types-B8Ssxqg4.mjs";
+import { a as LongPressEventType, c as LongPressProps, i as LongPressEvent, n as useLongPress, o as LongPressOptions, r as LongPressController, s as LongPressPointerType, t as createLongPress } from "./long-press-CRjjjJK2.mjs";
+import { createPress, usePress } from "./press.mjs";
+import { t as _default$4 } from "./visually-hidden-CekDwEwR.mjs";
+export { _default as Button, ButtonKeyboardAction, ButtonKeyboardPhase, _default$1 as Checkbox, CheckboxState, CollectionActiveChange, CollectionActiveChangeReason, CollectionDisabledBehavior, CollectionItem, CollectionItemInput, CollectionKey, CollectionNavigationDirection, CollectionNavigationOptions, CollectionRegistration, CollectionRegistry, CollectionRegistryOptions, CollectionTextSearchOptions, ComponentContext, ControllableState, ControllableStateOptions, DeterministicId, DeterministicIdChildScopeOptions, DeterministicIdOptions, DeterministicIdScope, DeterministicIdScopeOptions, DeterministicIdSeed, _default$2 as IdProvider, InteractionModality, InteractionModalityChange, InteractionModalityChangeReason, InteractionModalityOptions, InteractionModalityTracker, LongPressController, LongPressEvent, LongPressEventType, LongPressOptions, LongPressPointerType, LongPressProps, PressController, PressEvent, PressEventType, PressKeyboardBehavior, PressOptions, PressPointerType, PressProps, _default$3 as Primitive, PrimitiveAs, PrimitiveElement, StateUpdate, _default$4 as VisuallyHidden, createCollectionRegistry, createContext, createDeterministicIdScope, createInteractionModalityTracker, createLongPress, createPress, deriveDeterministicId, extractCollectionTextValue, getButtonKeyboardAction, getCheckboxState, isElementFocusVisible, normalizeCollectionTextValue, toDeterministicId, useControllableState, useDeterministicId, useInteractionModality, useLongPress, usePress };

package/dist/index.mjs

@@ -1,7 +1,12 @@
 import { n as getCheckboxState, t as CheckboxControl_default } from "./checkbox-B4y9GUen.mjs";
 import { useControllableState } from "./controllable-state.mjs";
+import { n as extractCollectionTextValue, r as normalizeCollectionTextValue, t as createCollectionRegistry } from "./collection-CoOROaho.mjs";
 import { createContext } from "./context.mjs";
-import { n as getButtonKeyboardAction, t as ActionButton_default } from "./button-8BOlFJNu.mjs";
-import { t as PrimitiveElement_default } from "./primitive-DJB7pOf3.mjs";
-import { t as VisuallyHidden_default } from "./visually-hidden-QENRapzW.mjs";
-export { ActionButton_default as Button, CheckboxControl_default as Checkbox, PrimitiveElement_default as Primitive, VisuallyHidden_default as VisuallyHidden, createContext, getButtonKeyboardAction, getCheckboxState, useControllableState };
+import { n as getButtonKeyboardAction, t as ActionButton_default } from "./button-CaLxP2l2.mjs";
+import { a as useDeterministicId, i as toDeterministicId, n as createDeterministicIdScope, r as deriveDeterministicId, t as DeterministicIdProvider_default } from "./id-CPBdeoL3.mjs";
+import { n as isElementFocusVisible, r as useInteractionModality, t as createInteractionModalityTracker } from "./interaction-modality-CO-eQzNy.mjs";
+import { n as usePress, t as createPress } from "./press-Bp57IOe2.mjs";
+import { createLongPress, useLongPress } from "./long-press.mjs";
+import { t as PrimitiveElement_default } from "./primitive-BE28SwD7.mjs";
+import { t as VisuallyHidden_default } from "./visually-hidden-CTSV3ctZ.mjs";
+export { ActionButton_default as Button, CheckboxControl_default as Checkbox, DeterministicIdProvider_default as IdProvider, PrimitiveElement_default as Primitive, VisuallyHidden_default as VisuallyHidden, createCollectionRegistry, createContext, createDeterministicIdScope, createInteractionModalityTracker, createLongPress, createPress, deriveDeterministicId, extractCollectionTextValue, getButtonKeyboardAction, getCheckboxState, isElementFocusVisible, normalizeCollectionTextValue, toDeterministicId, useControllableState, useDeterministicId, useInteractionModality, useLongPress, usePress };

package/dist/interaction-modality-CO-eQzNy.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 };