@vizejs/ui 0.387.0 → 0.389.0

package/dist/alert-BX93FNvj.d.mts

@@ -0,0 +1,92 @@
+import { ShallowRef } from "vue";
+
+//#region src/families/feedback/alert/alert-types.d.ts
+/** ARIA live-region roles accepted by the Alert primitive. */
+type AlertRole = "alert" | "status";
+/** Consumer styling variants exposed only through data attributes and slot state. */
+type AlertVariant = "danger" | "info" | "success" | "warning";
+/** Visibility state exposed to data attributes and slot consumers. */
+type AlertState = "closed" | "open";
+/** State exposed to the default slot for external chrome and dismissal composition. */
+interface AlertSlotState {
+  /** Whether the alert is currently visible and announceable. */
+  readonly open: boolean;
+  /** ARIA role used by the alert root. */
+  readonly role: AlertRole;
+  /** Visibility state mirrored to `data-state`. */
+  readonly state: AlertState;
+  /** Styling variant mirrored to `data-variant`. */
+  readonly variant: AlertVariant;
+}
+/** Methods and state exposed by the alert component instance. */
+interface AlertExpose {
+  /** Rendered alert root for composition with application-owned effects. */
+  readonly element: Readonly<ShallowRef<HTMLDivElement | null>>;
+}
+//#endregion
+//#region src/families/feedback/alert/alert.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Consumer-owned root id for labels, descriptions, or anchors.
+   *
+   * @default undefined
+   */
+  readonly id?: string;
+  /**
+   * Live-region role: `alert` is assertive, `status` is polite.
+   *
+   * @default "alert"
+   */
+  readonly role?: AlertRole;
+  /**
+   * Styling variant mirrored to `data-variant`; no CSS is emitted.
+   *
+   * @default "info"
+   */
+  readonly variant?: AlertVariant;
+  /**
+   * Whether the alert is visible and announceable.
+   *
+   * @default true
+   */
+  readonly open?: boolean;
+  /**
+   * Whether assistive technology should present the whole region on updates.
+   *
+   * @default true
+   */
+  readonly atomic?: boolean;
+  /**
+   * Accessible name when no visible label or `aria-labelledby` supplies one.
+   *
+   * @default undefined
+   */
+  readonly ariaLabel?: string;
+  /**
+   * Space-separated ids that label the alert.
+   *
+   * @default undefined
+   */
+  readonly ariaLabelledby?: string;
+  /**
+   * Space-separated ids that describe the alert.
+   *
+   * @default undefined
+   */
+  readonly ariaDescribedby?: string;
+};
+type __VLS_Slots = {
+  /** Renders alert content with current role, variant, and visibility state. */default(props: AlertSlotState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("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 { AlertState as a, AlertSlotState as i, AlertExpose as n, AlertVariant as o, AlertRole as r, _default as t };

package/dist/alert-DvhiFK_R.mjs

@@ -0,0 +1,92 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createElementBlock, defineComponent, openBlock, renderSlot, useTemplateRef } from "vue";
+//#region src/families/feedback/alert/alert.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"id",
+	"role",
+	"hidden",
+	"aria-label",
+	"aria-labelledby",
+	"aria-describedby",
+	"aria-live",
+	"aria-atomic",
+	"data-state",
+	"data-variant"
+];
+//#endregion
+//#region src/families/feedback/alert/alert.vue
+var alert_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "alert",
+	props: {
+		id: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		role: {
+			type: String,
+			required: false,
+			default: "alert"
+		},
+		variant: {
+			type: String,
+			required: false,
+			default: "info"
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		atomic: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaLabelledby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaDescribedby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		const live = computed(() => __props.role === "alert" ? "assertive" : "polite");
+		const state = computed(() => __props.open ? "open" : "closed");
+		__expose({ element });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				id: __props.id,
+				ref_key: "element",
+				ref: element,
+				role: __props.role,
+				hidden: __props.open ? void 0 : true,
+				"aria-label": __props.ariaLabel,
+				"aria-labelledby": __props.ariaLabelledby,
+				"aria-describedby": __props.ariaDescribedby,
+				"aria-live": live.value,
+				"aria-atomic": __props.atomic ? "true" : "false",
+				"data-vize-ui": "alert",
+				"data-state": state.value,
+				"data-variant": __props.variant
+			}, [renderSlot(_ctx.$slots, "default", {
+				open: __props.open,
+				role: __props.role,
+				state: state.value,
+				variant: __props.variant
+			}, void 0, true)], 8, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-308a7e89"]]);
+//#endregion
+export { alert_default as t };

package/dist/alert-dialog-D9tqXQ_Q.mjs

@@ -0,0 +1,176 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { l as dialogContext, o as dialog_content_default } from "./dialog-trigger-ppGKikEP.mjs";
+import { computed, createElementBlock, createVNode, defineComponent, guardReactiveProps, normalizeProps, openBlock, renderSlot, useTemplateRef, withCtx } from "vue";
+//#region src/families/overlays/alert-dialog/alert-dialog-content.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["data-state", "data-modal"];
+//#endregion
+//#region src/families/overlays/alert-dialog/alert-dialog-content.vue
+var alert_dialog_content_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "alert-dialog-content",
+	props: {
+		forceMount: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		trapFocus: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		autoFocus: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		restoreFocus: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		inertOutside: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		lockScroll: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		closeOnEscape: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		closeOnPointerDownOutside: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		closeOnFocusOutside: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaLabelledby: {
+			type: [String, null],
+			required: false,
+			default: () => void 0
+		},
+		ariaDescribedby: {
+			type: [String, null],
+			required: false,
+			default: () => void 0
+		}
+	},
+	emits: [
+		"open-auto-focus",
+		"close-auto-focus",
+		"escape-key-down",
+		"pointer-down-outside",
+		"focus-outside",
+		"interact-outside",
+		"dismiss"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const context = dialogContext.use();
+		const content = useTemplateRef("content");
+		const element = computed(() => content.value?.element ?? null);
+		const open = computed(() => context.open.value);
+		const modal = computed(() => context.modal.value);
+		const state = computed(() => context.state.value);
+		const slotState = computed(() => ({
+			modal: modal.value,
+			open: open.value,
+			state: state.value
+		}));
+		function focusContent(options) {
+			content.value?.focusContent(options);
+		}
+		__expose({
+			element,
+			focusContent,
+			focusFirst: () => content.value?.focusFirst() ?? null,
+			modal,
+			open,
+			state
+		});
+		function onOpenAutoFocus(event) {
+			emit("open-auto-focus", event);
+		}
+		function onCloseAutoFocus(event) {
+			emit("close-auto-focus", event);
+		}
+		function onEscapeKeyDown(event) {
+			emit("escape-key-down", event);
+		}
+		function onPointerDownOutside(event) {
+			emit("pointer-down-outside", event);
+		}
+		function onFocusOutside(event) {
+			emit("focus-outside", event);
+		}
+		function onInteractOutside(event) {
+			emit("interact-outside", event);
+		}
+		function onDismiss(event) {
+			emit("dismiss", event);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-vize-ui": "alert-dialog-content",
+				part: "root",
+				"data-state": state.value,
+				"data-modal": modal.value ? "true" : "false"
+			}, [createVNode(dialog_content_default, {
+				ref_key: "content",
+				ref: content,
+				role: "alertdialog",
+				"force-mount": __props.forceMount,
+				"trap-focus": __props.trapFocus,
+				"auto-focus": __props.autoFocus,
+				"restore-focus": __props.restoreFocus,
+				"inert-outside": __props.inertOutside,
+				"lock-scroll": __props.lockScroll,
+				"close-on-escape": __props.closeOnEscape,
+				"close-on-pointer-down-outside": __props.closeOnPointerDownOutside,
+				"close-on-focus-outside": __props.closeOnFocusOutside,
+				"aria-label": __props.ariaLabel,
+				"aria-labelledby": __props.ariaLabelledby,
+				"aria-describedby": __props.ariaDescribedby,
+				onOpenAutoFocus,
+				onCloseAutoFocus,
+				onEscapeKeyDown,
+				onPointerDownOutside,
+				onFocusOutside,
+				onInteractOutside,
+				onDismiss
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)]),
+				_: 3
+			}, 8, [
+				"force-mount",
+				"trap-focus",
+				"auto-focus",
+				"restore-focus",
+				"inert-outside",
+				"lock-scroll",
+				"close-on-escape",
+				"close-on-pointer-down-outside",
+				"close-on-focus-outside",
+				"aria-label",
+				"aria-labelledby",
+				"aria-describedby"
+			])], 8, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-03cd685d"]]);
+//#endregion
+export { alert_dialog_content_default as t };

package/dist/alert-dialog.d.mts

@@ -0,0 +1,2 @@
+import { Ao as AlertDialogDescriptionExpose, Bo as _default$5, Do as AlertDialogAutoFocusEvent, Eo as AlertDialogActionExpose, Fo as AlertDialogState, Go as _default, Ho as _default$3, Io as AlertDialogTitleExpose, Lo as AlertDialogTriggerExpose, Mo as AlertDialogPortalExpose, No as AlertDialogRootExpose, Oo as AlertDialogCancelExpose, Po as AlertDialogSlotState, Ro as _default$7, To as _default$2, Vo as _default$4, Wo as _default$1, jo as AlertDialogOverlayExpose, ko as AlertDialogContentExpose, zo as _default$6 } from "./announcer-CuBryPW9.mjs";
+export { _default as AlertDialog, _default as AlertDialogRoot, _default$1 as AlertDialogAction, _default$1 as AlertDialogCancel, type AlertDialogActionExpose, type AlertDialogAutoFocusEvent, type AlertDialogCancelExpose, _default$2 as AlertDialogContent, type AlertDialogContentExpose, _default$3 as AlertDialogDescription, type AlertDialogDescriptionExpose, _default$4 as AlertDialogOverlay, type AlertDialogOverlayExpose, _default$5 as AlertDialogPortal, type AlertDialogPortalExpose, type AlertDialogRootExpose, type AlertDialogSlotState, type AlertDialogState, _default$6 as AlertDialogTitle, type AlertDialogTitleExpose, _default$7 as AlertDialogTrigger, type AlertDialogTriggerExpose };

package/dist/alert-dialog.mjs

@@ -0,0 +1,3 @@
+import { a as dialog_description_default, c as dialog_root_default, i as dialog_overlay_default, n as dialog_title_default, r as dialog_portal_default, s as dialog_close_default, t as dialog_trigger_default } from "./dialog-trigger-ppGKikEP.mjs";
+import { t as alert_dialog_content_default } from "./alert-dialog-D9tqXQ_Q.mjs";
+export { dialog_root_default as AlertDialog, dialog_root_default as AlertDialogRoot, dialog_close_default as AlertDialogAction, dialog_close_default as AlertDialogCancel, alert_dialog_content_default as AlertDialogContent, dialog_description_default as AlertDialogDescription, dialog_overlay_default as AlertDialogOverlay, dialog_portal_default as AlertDialogPortal, dialog_title_default as AlertDialogTitle, dialog_trigger_default as AlertDialogTrigger };

package/dist/alert.d.mts

@@ -0,0 +1,2 @@
+import { a as AlertState, i as AlertSlotState, n as AlertExpose, o as AlertVariant, r as AlertRole, t as _default } from "./alert-BX93FNvj.mjs";
+export { _default as Alert, type AlertExpose, type AlertRole, type AlertSlotState, type AlertState, type AlertVariant };

package/dist/alert.mjs

@@ -0,0 +1,2 @@
+import { t as alert_default } from "./alert-DvhiFK_R.mjs";
+export { alert_default as Alert };

package/dist/announcer-CW079p2E.mjs

@@ -0,0 +1,258 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { createContext } from "./context.mjs";
+import { t as createLiveRegion } from "./live-region-runtime-DVUch8Lu.mjs";
+import { createCommentVNode, createElementBlock, defineComponent, getCurrentScope, nextTick, onScopeDispose, openBlock, renderSlot, shallowReadonly, shallowRef, toDisplayString, toRef, toValue, unref } from "vue";
+//#region src/families/accessibility/announcer/announcer-runtime.ts
+const invalidOptionDiagnostic = "VIZE_UI_ANNOUNCER_OPTION";
+const disposedDiagnostic = "VIZE_UI_ANNOUNCER_DISPOSED";
+const setupDiagnostic$1 = "VIZE_UI_ANNOUNCER_SETUP";
+const politenessValues = new Set(["assertive", "polite"]);
+/** Typed announcer context provided by AnnouncerProvider. */
+const announcerContext = createContext("Announcer");
+function readPoliteness(value, fallback) {
+	const resolved = toValue(value);
+	if (resolved === void 0) return fallback;
+	if (!politenessValues.has(resolved)) throw new TypeError(`${invalidOptionDiagnostic}: politeness must resolve to polite or assertive`);
+	return resolved;
+}
+function validateMessage(text, options) {
+	if (typeof text !== "string") throw new TypeError(`${invalidOptionDiagnostic}: announcement text must be a string`);
+	if (options.politeness !== void 0) readPoliteness(options.politeness, "polite");
+	if (options.key !== void 0 && (typeof options.key !== "string" || options.key.length === 0)) throw new TypeError(`${invalidOptionDiagnostic}: a coalescing key must be a non-empty string`);
+}
+/**
+* Create an SSR-safe announcement queue.
+*
+* Announcements flush sequentially into one polite and one assertive
+* live-region channel, so status updates and errors never overwrite each
+* other mid-announcement. The server renders both channels empty: queued text
+* only ever reaches the DOM after client-side ticks.
+*/
+function createAnnouncer(options = {}) {
+	if (typeof options.politeness !== "function") readPoliteness(options.politeness, "polite");
+	const polite = createLiveRegion({ politeness: "polite" });
+	const assertive = createLiveRegion({ politeness: "assertive" });
+	const queue = [];
+	const pendingCount = shallowRef(0);
+	let inFlight;
+	let disposed = false;
+	let flushing = false;
+	const assertAlive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const syncPending = () => {
+		pendingCount.value = queue.length;
+	};
+	const flush = async () => {
+		while (!disposed) {
+			const next = queue.shift();
+			if (next === void 0) break;
+			inFlight = next;
+			syncPending();
+			(next.politeness === "assertive" ? assertive : polite).announce(next.text);
+			await nextTick();
+			await nextTick();
+		}
+		inFlight = void 0;
+		flushing = false;
+	};
+	const scheduleFlush = () => {
+		if (flushing) return;
+		flushing = true;
+		flush();
+	};
+	const isDuplicate = (text, politeness) => {
+		if (inFlight !== void 0 && inFlight.text === text && inFlight.politeness === politeness) return true;
+		return queue.some((pending) => pending.text === text && pending.politeness === politeness);
+	};
+	return Object.freeze({
+		politeMessage: polite.message,
+		assertiveMessage: assertive.message,
+		pendingCount: shallowReadonly(pendingCount),
+		announce: (text, messageOptions = {}) => {
+			assertAlive();
+			validateMessage(text, messageOptions);
+			const politeness = messageOptions.politeness ?? readPoliteness(options.politeness, "polite");
+			const keyed = messageOptions.key === void 0 ? void 0 : queue.find((pending) => pending.key === messageOptions.key);
+			if (keyed !== void 0) {
+				keyed.text = text;
+				keyed.politeness = politeness;
+				return true;
+			}
+			if (isDuplicate(text, politeness)) return false;
+			const message = {
+				text,
+				politeness,
+				key: messageOptions.key
+			};
+			if (politeness === "assertive") {
+				const firstPolite = queue.findIndex((pending) => pending.politeness === "polite");
+				queue.splice(firstPolite === -1 ? queue.length : firstPolite, 0, message);
+			} else queue.push(message);
+			syncPending();
+			scheduleFlush();
+			return true;
+		},
+		cancel: (key) => {
+			assertAlive();
+			const index = queue.findIndex((pending) => pending.key === key);
+			if (index === -1) return false;
+			queue.splice(index, 1);
+			syncPending();
+			return true;
+		},
+		clear: () => {
+			assertAlive();
+			queue.length = 0;
+			syncPending();
+			polite.clear();
+			assertive.clear();
+		},
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			queue.length = 0;
+			pendingCount.value = 0;
+			polite.dispose();
+			assertive.dispose();
+		}
+	});
+}
+/** Create an announcer disposed with the current Vue effect scope. */
+function useAnnouncer(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic$1}: use inside component setup or an active effect scope`);
+	const controller = createAnnouncer(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+/**
+* Resolve provider ownership during component setup.
+*
+* The outermost provider creates and owns the announcement queue; nested
+* providers reuse it, so a document never renders duplicate live regions no
+* matter how many islands or layout shells declare their own provider.
+*/
+function useAnnouncerOwnership(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic$1}: use inside component setup or an active effect scope`);
+	const existing = announcerContext.useOptional();
+	if (existing !== void 0) return Object.freeze({
+		announcer: existing,
+		isOwner: false
+	});
+	const announcer = useAnnouncer(options);
+	announcerContext.provide(announcer);
+	return Object.freeze({
+		announcer,
+		isOwner: true
+	});
+}
+//#endregion
+//#region src/families/accessibility/announcer/announcer-busy.ts
+const busyDiagnostic = "VIZE_UI_ANNOUNCER_BUSY";
+const setupDiagnostic = "VIZE_UI_ANNOUNCER_SETUP";
+const busyKeySequences = /* @__PURE__ */ new WeakMap();
+function nextBusyKey(announcer) {
+	const sequence = (busyKeySequences.get(announcer) ?? 0) + 1;
+	busyKeySequences.set(announcer, sequence);
+	return `vize-ui-busy-${sequence}`;
+}
+function readLabel(value) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${busyDiagnostic}: a busy announcement needs a non-empty label`);
+	return value;
+}
+/**
+* Begin announcing one busy task: loading, streaming, or background work.
+*
+* The label is announced immediately. Progress updates coalesce onto one
+* queue slot so a stream cannot flood assistive technology, and `end` cancels
+* unspoken progress before optionally announcing the outcome. Bind the
+* busy scope's `aria-busy` to `isBusy` so partial content is not read early.
+*/
+function createBusyAnnouncement(announcer, options) {
+	const label = readLabel(options.label);
+	const politeness = options.politeness ?? "polite";
+	const key = nextBusyKey(announcer);
+	const isBusy = shallowRef(true);
+	announcer.announce(label, {
+		key,
+		politeness
+	});
+	return Object.freeze({
+		isBusy: shallowReadonly(isBusy),
+		update: (text) => {
+			if (!isBusy.value) throw new Error(`${busyDiagnostic}: the busy announcement has already ended`);
+			announcer.announce(text, {
+				key,
+				politeness
+			});
+		},
+		end: (text) => {
+			if (!isBusy.value) return;
+			isBusy.value = false;
+			announcer.cancel(key);
+			if (text !== void 0) announcer.announce(text, { politeness });
+		}
+	});
+}
+/** Begin a busy announcement that silently ends with the current effect scope. */
+function useBusyAnnouncement(announcer, options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const busy = createBusyAnnouncement(announcer, options);
+	onScopeDispose(() => busy.end());
+	return busy;
+}
+//#endregion
+//#region src/families/accessibility/announcer/announcer-provider.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["data-vize-announcer"];
+const _hoisted_2 = ["aria-atomic"];
+const _hoisted_3 = ["aria-atomic"];
+//#endregion
+//#region src/families/accessibility/announcer/announcer-provider.vue
+var announcer_provider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "announcer-provider",
+	props: {
+		politeness: {
+			type: String,
+			required: false,
+			default: "polite"
+		},
+		atomic: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const ownership = useAnnouncerOwnership({ politeness: toRef(() => __props.politeness) });
+		__expose({
+			announcer: ownership.announcer,
+			isOwner: ownership.isOwner,
+			announce: ownership.announcer.announce,
+			clear: ownership.announcer.clear
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-vize-ui": "announcer",
+				"data-vize-announcer": unref(ownership).isOwner ? "owner" : "delegate"
+			}, [
+				unref(ownership).isOwner ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					"data-vize-ui": "announcer-region",
+					"aria-live": "polite",
+					role: "status",
+					"aria-atomic": __props.atomic ? "true" : "false"
+				}, toDisplayString(unref(ownership).announcer.politeMessage.value), 9, _hoisted_2)) : createCommentVNode("v-if", true),
+				unref(ownership).isOwner ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					"data-vize-ui": "announcer-region",
+					"aria-live": "assertive",
+					role: "alert",
+					"aria-atomic": __props.atomic ? "true" : "false"
+				}, toDisplayString(unref(ownership).announcer.assertiveMessage.value), 9, _hoisted_3)) : createCommentVNode("v-if", true),
+				renderSlot(_ctx.$slots, "default", { announcer: unref(ownership).announcer }, void 0, true)
+			], 8, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-56d8d13d"]]);
+//#endregion
+export { createAnnouncer as a, announcerContext as i, createBusyAnnouncement as n, useAnnouncer as o, useBusyAnnouncement as r, useAnnouncerOwnership as s, announcer_provider_default as t };