@vizejs/ui 0.387.0 → 0.388.0

package/dist/shortcut-DAZJ9LEd.d.mts

@@ -0,0 +1,231 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/families/interaction/shortcut/shortcut-types.d.ts
+/** Modifier layout family used to resolve `Mod` and to format keycaps. */
+type ShortcutPlatform = "apple" | "standard";
+/** One normalized simultaneous key press within a shortcut. */
+interface ShortcutChord {
+  /** Canonical `KeyboardEvent.key` value; single characters are lowercase. */
+  readonly key: string;
+  /** Alt (Option) must be held. */
+  readonly altKey: boolean;
+  /** Control must be held. */
+  readonly ctrlKey: boolean;
+  /** Meta (Command / Windows) must be held. */
+  readonly metaKey: boolean;
+  /** Shift must be held. */
+  readonly shiftKey: boolean;
+}
+/** Ordered chord steps typed one after another, e.g. `G` then `D`. */
+type ShortcutSequence = readonly ShortcutChord[];
+/** Options for `parseShortcut` and the keycap formatting helpers. */
+interface ShortcutParseOptions {
+  /**
+   * Layout used to resolve the `Mod` platform modifier: Meta on `apple`,
+   * Control on `standard`.
+   *
+   * @default detectShortcutPlatform()
+   */
+  readonly platform?: ShortcutPlatform;
+}
+/** Presentation options for `formatShortcut` and `getShortcutKeycaps`. */
+interface ShortcutFormatOptions extends ShortcutParseOptions {
+  /**
+   * `symbol` renders platform glyphs such as `⌘` and `⇧`; `text` renders
+   * spelled-out names such as `Ctrl` and `Shift`.
+   *
+   * @default "symbol" on apple, "text" on standard
+   */
+  readonly style?: "symbol" | "text";
+}
+/** Immutable description of one dispatched shortcut. */
+interface ShortcutMatch {
+  /** Normalized sequence that completed. */
+  readonly shortcut: ShortcutSequence;
+  /** Scope that owned the winning binding. */
+  readonly scope: string;
+  /** Help description supplied at registration, or `null`. */
+  readonly description: string | null;
+  /** Native event that completed the sequence. */
+  readonly originalEvent: KeyboardEvent;
+}
+/** One registered binding, as surfaced by help and conflict metadata. */
+interface ShortcutBindingInfo {
+  /** Normalized sequence this binding listens for. */
+  readonly shortcut: ShortcutSequence;
+  /** Scope name the binding belongs to. */
+  readonly scope: string;
+  /** Help description supplied at registration, or `null`. */
+  readonly description: string | null;
+}
+/** Bindings in one scope that listen for the same normalized sequence. */
+interface ShortcutConflict {
+  /** Scope in which the collision occurs. */
+  readonly scope: string;
+  /** Normalized sequence claimed more than once. */
+  readonly shortcut: ShortcutSequence;
+  /** Every binding claiming the sequence, in registration order. */
+  readonly bindings: readonly ShortcutBindingInfo[];
+}
+/** Options accepted by `ShortcutRegistry.register`. */
+interface ShortcutBindingOptions {
+  /** Pattern such as `"Mod+K"` or `"G D"`, or a pre-parsed sequence. */
+  readonly shortcut: string | ShortcutSequence;
+  /** Called when the sequence completes and this binding wins routing. */
+  readonly handler: (match: ShortcutMatch) => void;
+  /**
+   * Scope owning the binding. Non-global scopes only receive input while
+   * activated, and later-activated scopes shadow earlier ones.
+   *
+   * @default "global"
+   */
+  readonly scope?: string;
+  /**
+   * Additional enablement gate checked on every dispatch.
+   *
+   * @default true
+   */
+  readonly when?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Cancel the native action when the binding matches or extends a pending
+   * sequence.
+   *
+   * @default true
+   */
+  readonly preventDefault?: boolean;
+  /**
+   * Accept auto-repeated keydown events.
+   *
+   * @default false
+   */
+  readonly allowRepeat?: boolean;
+  /**
+   * Dispatch even when the event originates from text-editing elements.
+   *
+   * @default false
+   */
+  readonly allowInEditable?: boolean;
+  /** Help description surfaced through binding and conflict metadata. */
+  readonly description?: string;
+}
+/** Stable keyboard handler to spread onto an element-scoped shortcut host. */
+interface ShortcutProps {
+  readonly onKeydown: (event: KeyboardEvent) => void;
+}
+/** Options for `createShortcutRegistry` and `useShortcutRegistry`. */
+interface ShortcutRegistryOptions {
+  /**
+   * Event target that feeds the registry: a document, window, shadow root, or
+   * element. `undefined` resolves the ambient document on the client and
+   * nothing during server rendering; `null` disables automatic attachment.
+   *
+   * @default globalThis.document ?? null
+   */
+  readonly target?: MaybeRefOrGetter<EventTarget | null | undefined>;
+  /**
+   * Layout used to resolve the `Mod` platform modifier.
+   *
+   * @default detectShortcutPlatform()
+   */
+  readonly platform?: ShortcutPlatform;
+  /**
+   * Idle milliseconds before a pending multi-chord sequence resets.
+   *
+   * @default 1000
+   */
+  readonly sequenceTimeout?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Ignore input and clear any pending sequence while true.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Attach native listeners during the capture phase.
+   *
+   * @default false
+   */
+  readonly capture?: boolean;
+}
+/** Scoped, sequence-aware keyboard shortcut registry. */
+interface ShortcutRegistry {
+  /** Chords accepted so far by a pending multi-chord sequence. */
+  readonly pendingSequence: Readonly<ShallowRef<ShortcutSequence>>;
+  /** Non-global scopes currently activated, in activation order. */
+  readonly activeScopes: Readonly<ShallowRef<readonly string[]>>;
+  /** Stable keyboard handler for declarative element-scoped hosts. */
+  readonly shortcutProps: Readonly<ShortcutProps>;
+  /** Add one binding and return its releaser. */
+  readonly register: (binding: ShortcutBindingOptions) => () => void;
+  /** Activate a scope on top of the stack and return its releaser. */
+  readonly activateScope: (scope: string) => () => void;
+  /** Route one keyboard event and report whether a binding completed. */
+  readonly input: (event: KeyboardEvent) => boolean;
+  /** Attach native listeners to an extra target and return the detacher. */
+  readonly attach: (target: EventTarget, options?: {
+    readonly capture?: boolean;
+  }) => () => void;
+  /** Clear a pending sequence and report whether one was pending. */
+  readonly reset: () => boolean;
+  /** Snapshot every registered binding in registration order. */
+  readonly getBindings: () => readonly ShortcutBindingInfo[];
+  /** Report same-scope bindings that claim an identical sequence. */
+  readonly getConflicts: () => readonly ShortcutConflict[];
+  /** Detach listeners, clear timers, and make imperative calls terminal. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/families/interaction/shortcut/shortcut-parse.d.ts
+/**
+ * Detect the modifier layout of the current environment.
+ *
+ * Server rendering has no ambient keyboard, so the detector deterministically
+ * reports `standard` there; pass an explicit platform when formatting keycaps
+ * into server-rendered markup.
+ */
+declare function detectShortcutPlatform(): ShortcutPlatform;
+/**
+ * Parse a shortcut pattern into a normalized chord sequence.
+ *
+ * Chord steps are separated by whitespace and each step joins modifiers and
+ * one key with `+`, e.g. `"Mod+K"`, `"Ctrl+Shift+P"`, or `"G D"`. `Mod`
+ * resolves to Meta on Apple layouts and Control elsewhere.
+ */
+declare function parseShortcut(pattern: string, options?: ShortcutParseOptions): ShortcutSequence;
+/** Stable identity string used for routing and conflict detection. */
+declare function serializeShortcut(sequence: ShortcutSequence): string;
+//#endregion
+//#region src/families/interaction/shortcut/shortcut-format.d.ts
+/**
+ * Break a shortcut into display keycaps for `<kbd>` rendering.
+ *
+ * The result carries one array per sequence step; each step lists modifier
+ * keycaps in platform order followed by the key keycap. Formatting is
+ * deterministic for a given platform, so pass an explicit platform when the
+ * output is server-rendered.
+ */
+declare function getShortcutKeycaps(shortcut: string | ShortcutSequence, options?: ShortcutFormatOptions): readonly (readonly string[])[];
+/**
+ * Format a shortcut as one display string, e.g. `⇧⌘K` or `Ctrl+Shift+K`.
+ *
+ * Apple symbol keycaps join without separators; every other combination joins
+ * with `+`. Sequence steps are joined with a single space.
+ */
+declare function formatShortcut(shortcut: string | ShortcutSequence, options?: ShortcutFormatOptions): string;
+//#endregion
+//#region src/families/interaction/shortcut/shortcut.d.ts
+/**
+ * Create an SSR-safe, scope-aware keyboard shortcut registry.
+ *
+ * The registry resolves `Mod` for one platform, routes chords and multi-chord
+ * sequences to the winning binding, and never touches the DOM on the server:
+ * with no ambient document it stays detached until a target appears or events
+ * are fed through {@link ShortcutRegistry.input}. Call
+ * {@link ShortcutRegistry.dispose} when using this factory outside a Vue
+ * effect scope.
+ */
+declare function createShortcutRegistry(options?: ShortcutRegistryOptions): ShortcutRegistry;
+/** Create a shortcut registry disposed with the current Vue effect scope. */
+declare function useShortcutRegistry(options?: ShortcutRegistryOptions): ShortcutRegistry;
+//#endregion
+export { ShortcutRegistry as _, detectShortcutPlatform as a, ShortcutBindingInfo as c, ShortcutConflict as d, ShortcutFormatOptions as f, ShortcutProps as g, ShortcutPlatform as h, getShortcutKeycaps as i, ShortcutBindingOptions as l, ShortcutParseOptions as m, useShortcutRegistry as n, parseShortcut as o, ShortcutMatch as p, formatShortcut as r, serializeShortcut as s, createShortcutRegistry as t, ShortcutChord as u, ShortcutRegistryOptions as v, ShortcutSequence as y };

package/dist/shortcut.d.mts

@@ -0,0 +1,2 @@
+import { _ as ShortcutRegistry, a as detectShortcutPlatform, c as ShortcutBindingInfo, d as ShortcutConflict, f as ShortcutFormatOptions, g as ShortcutProps, h as ShortcutPlatform, i as getShortcutKeycaps, l as ShortcutBindingOptions, m as ShortcutParseOptions, n as useShortcutRegistry, o as parseShortcut, p as ShortcutMatch, r as formatShortcut, s as serializeShortcut, t as createShortcutRegistry, u as ShortcutChord, v as ShortcutRegistryOptions, y as ShortcutSequence } from "./shortcut-DAZJ9LEd.mjs";
+export { type ShortcutBindingInfo, type ShortcutBindingOptions, type ShortcutChord, type ShortcutConflict, type ShortcutFormatOptions, type ShortcutMatch, type ShortcutParseOptions, type ShortcutPlatform, type ShortcutProps, type ShortcutRegistry, type ShortcutRegistryOptions, type ShortcutSequence, createShortcutRegistry, detectShortcutPlatform, formatShortcut, getShortcutKeycaps, parseShortcut, serializeShortcut, useShortcutRegistry };

package/dist/shortcut.mjs

@@ -0,0 +1,2 @@
+import { a as detectShortcutPlatform, i as getShortcutKeycaps, n as useShortcutRegistry, o as parseShortcut, r as formatShortcut, s as serializeShortcut, t as createShortcutRegistry } from "./shortcut-CvA_o0_F.mjs";
+export { createShortcutRegistry, detectShortcutPlatform, formatShortcut, getShortcutKeycaps, parseShortcut, serializeShortcut, useShortcutRegistry };

package/dist/skeleton-BYXXcwTH.mjs

@@ -0,0 +1,101 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, resolveDynamicComponent, useTemplateRef, withCtx } from "vue";
+//#endregion
+//#region src/families/feedback/skeleton/skeleton.vue
+var skeleton_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "skeleton",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "div"
+		},
+		loading: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		visible: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaHidden: {
+			type: Boolean,
+			required: false,
+			default: () => void 0
+		},
+		blockSize: {
+			type: String,
+			required: false,
+			default: "1em"
+		},
+		inlineSize: {
+			type: String,
+			required: false,
+			default: "100%"
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		const loadingState = computed(() => __props.loading);
+		const visibleState = computed(() => __props.visible);
+		const state = computed(() => visibleState.value ? loadingState.value ? "loading" : "loaded" : "hidden");
+		const hasAriaLabel = computed(() => __props.ariaLabel != null && __props.ariaLabel.length > 0);
+		const hiddenFromAssistiveTechnology = computed(() => __props.ariaHidden ?? !hasAriaLabel.value);
+		const ariaState = computed(() => hiddenFromAssistiveTechnology.value ? "decorative" : "status");
+		const slotState = computed(() => ({
+			ariaState: ariaState.value,
+			loading: loadingState.value,
+			state: state.value,
+			visible: visibleState.value
+		}));
+		const skeletonStyle = computed(() => ({
+			"--vize-ui-skeleton-block-size": __props.blockSize,
+			"--vize-ui-skeleton-inline-size": __props.inlineSize
+		}));
+		const intrinsicProps = computed(() => ({ style: skeletonStyle.value }));
+		__expose({
+			ariaState,
+			element,
+			loading: loadingState,
+			state,
+			visible: visibleState
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), mergeProps({
+				ref_key: "element",
+				ref: element,
+				hidden: __props.visible ? void 0 : true,
+				role: ariaState.value === "status" ? "status" : void 0,
+				"aria-hidden": ariaState.value === "decorative" ? "true" : void 0,
+				"aria-label": ariaState.value === "status" ? __props.ariaLabel : void 0,
+				"data-vize-ui": "skeleton",
+				part: "root",
+				"data-state": state.value,
+				"data-loading": __props.loading ? "true" : "false",
+				"data-visible": __props.visible ? "true" : "false",
+				"data-aria-state": ariaState.value
+			}, intrinsicProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)]),
+				_: 3
+			}, 16, [
+				"hidden",
+				"role",
+				"aria-hidden",
+				"aria-label",
+				"data-state",
+				"data-loading",
+				"data-visible",
+				"data-aria-state"
+			]);
+		};
+	}
+}), [["__scopeId", "data-v-2951ee75"]]);
+//#endregion
+export { skeleton_default as t };

package/dist/skeleton-CQW-Tsnt.d.mts

@@ -0,0 +1,99 @@
+import { t as PrimitiveAs } from "./primitive-BE2mdUcw.mjs";
+import { ComponentPublicInstance } from "vue";
+
+//#region src/families/feedback/skeleton/skeleton-types.d.ts
+/** Accessibility state derived from Skeleton props. */
+type SkeletonAriaState = "decorative" | "status";
+/** Visibility and loading state mirrored to `data-state`. */
+type SkeletonState = "hidden" | "loaded" | "loading";
+/** Rendered value exposed by {@link Skeleton}. */
+type SkeletonElement = Element | ComponentPublicInstance;
+/** State exposed to the default Skeleton slot. */
+interface SkeletonSlotState {
+  /** Whether the placeholder represents work still loading. */
+  readonly loading: boolean;
+  /** Whether the placeholder remains visible in layout. */
+  readonly visible: boolean;
+  /** Stable state token for styling and tests. */
+  readonly state: SkeletonState;
+  /** Whether accessibility semantics are decorative or status-like. */
+  readonly ariaState: SkeletonAriaState;
+}
+/** Public component instance exposed by the Skeleton primitive. */
+interface SkeletonExpose extends SkeletonSlotState {
+  /** Rendered host element or component instance. */
+  readonly element: SkeletonElement | null;
+}
+/** Inline style hooks applied to the rendered host. */
+interface SkeletonStyle {
+  /** Consumer-overridable block size hook for placeholder styling. */
+  readonly "--vize-ui-skeleton-block-size": string;
+  /** Consumer-overridable inline size hook for placeholder styling. */
+  readonly "--vize-ui-skeleton-inline-size": string;
+}
+//#endregion
+//#region src/families/feedback/skeleton/skeleton.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Native element, custom element, or component to render.
+   *
+   * @default "div"
+   */
+  readonly as?: PrimitiveAs;
+  /**
+   * Whether the placeholder represents pending content.
+   *
+   * @default true
+   */
+  readonly loading?: boolean;
+  /**
+   * Whether the placeholder remains rendered and visible in layout.
+   *
+   * @default true
+   */
+  readonly visible?: boolean;
+  /**
+   * Accessible status text when the skeleton should be announced.
+   *
+   * @default undefined
+   */
+  readonly ariaLabel?: string;
+  /**
+   * Override the default accessibility policy. By default, labelled skeletons
+   * are exposed as status regions and unlabelled skeletons are decorative.
+   *
+   * @default undefined
+   */
+  readonly ariaHidden?: boolean;
+  /**
+   * Value published to `--vize-ui-skeleton-block-size`.
+   *
+   * @default "1em"
+   */
+  readonly blockSize?: string;
+  /**
+   * Value published to `--vize-ui-skeleton-inline-size`.
+   *
+   * @default "100%"
+   */
+  readonly inlineSize?: string;
+};
+type __VLS_Slots = {
+  /** Optional placeholder content. Receives current loading, visibility, and ARIA state. */default(props: SkeletonSlotState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  ariaState: import("vue").ComputedRef<SkeletonAriaState>;
+  element: Readonly<import("vue").ShallowRef<SkeletonElement | null>>;
+  loading: import("vue").ComputedRef<boolean>;
+  state: import("vue").ComputedRef<SkeletonState>;
+  visible: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, 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 { SkeletonSlotState as a, SkeletonExpose as i, SkeletonAriaState as n, SkeletonState as o, SkeletonElement as r, SkeletonStyle as s, _default as t };

package/dist/skeleton.d.mts

@@ -0,0 +1,2 @@
+import { a as SkeletonSlotState, i as SkeletonExpose, n as SkeletonAriaState, o as SkeletonState, r as SkeletonElement, s as SkeletonStyle, t as _default } from "./skeleton-CQW-Tsnt.mjs";
+export { _default as Skeleton, type SkeletonAriaState, type SkeletonElement, type SkeletonExpose, type SkeletonSlotState, type SkeletonState, type SkeletonStyle };

package/dist/skeleton.mjs

@@ -0,0 +1,2 @@
+import { t as skeleton_default } from "./skeleton-BYXXcwTH.mjs";
+export { skeleton_default as Skeleton };

package/dist/skip-link-BUp9HXXt.mjs

@@ -0,0 +1,164 @@
+import { a as useDeterministicId } from "./deterministic-id-yMq4HfmS.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, ref, renderSlot, resolveDynamicComponent, unref, useTemplateRef, withCtx } from "vue";
+//#region src/families/navigation/skip-link/skip-link.vue?vue&type=script&setup=true&lang.ts
+const DEFAULT_HREF = "#main";
+//#endregion
+//#region src/families/navigation/skip-link/skip-link.vue
+var skip_link_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "skip-link",
+	props: {
+		id: {
+			type: [String, null],
+			required: false,
+			default: () => void 0
+		},
+		href: {
+			type: null,
+			required: false,
+			default: () => DEFAULT_HREF
+		},
+		focusTarget: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	emits: ["activate"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const element = useTemplateRef("element");
+		const linkId = useDeterministicId({
+			id: () => __props.id,
+			hint: "skip-link"
+		});
+		const focused = ref(false);
+		const renderedHref = computed(() => normalizeHashHref(__props.href));
+		const anchorAttributes = computed(() => renderedHref.value === void 0 ? {} : { href: renderedHref.value });
+		const targetId = computed(() => renderedHref.value?.slice(1));
+		const unavailable = computed(() => renderedHref.value === void 0);
+		const state = computed(() => {
+			if (unavailable.value) return "invalid";
+			return focused.value ? "focused" : "idle";
+		});
+		const slotState = computed(() => ({
+			focused: focused.value,
+			href: renderedHref.value,
+			state: state.value,
+			targetId: targetId.value,
+			unavailable: unavailable.value
+		}));
+		function onFocus() {
+			focused.value = true;
+		}
+		function onBlur() {
+			focused.value = false;
+		}
+		function onClick(event) {
+			const current = getCurrentLink();
+			if (current === null) {
+				event.preventDefault();
+				event.stopImmediatePropagation();
+				return;
+			}
+			const result = __props.focusTarget ? focusTarget() : {
+				target: getTarget(),
+				focused: false
+			};
+			emit("activate", event, {
+				focused: result.focused,
+				href: current.href,
+				target: result.target,
+				targetId: current.targetId
+			});
+		}
+		function getCurrentLink() {
+			if (renderedHref.value === void 0 || targetId.value === void 0) return null;
+			return {
+				href: renderedHref.value,
+				targetId: targetId.value
+			};
+		}
+		function normalizeHashHref(value) {
+			const normalized = value.trim();
+			if (!normalized.startsWith("#") || normalized.length === 1) return void 0;
+			return hasAsciiWhitespaceOrControl(normalized) ? void 0 : normalized;
+		}
+		function hasAsciiWhitespaceOrControl(value) {
+			for (let index = 0; index < value.length; index++) {
+				const code = value.charCodeAt(index);
+				if (code <= 32 || code === 127) return true;
+			}
+			return false;
+		}
+		function getTarget() {
+			if (targetId.value === void 0 || typeof document === "undefined") return null;
+			const target = document.getElementById(targetId.value);
+			return target instanceof HTMLElement ? target : null;
+		}
+		function focus(options) {
+			element.value?.focus(options);
+		}
+		function focusTarget(options) {
+			const target = getTarget();
+			if (target === null) return {
+				target: null,
+				focused: false
+			};
+			const hadTabIndex = target.hasAttribute("tabindex");
+			if (!hadTabIndex) target.setAttribute("tabindex", "-1");
+			target.focus(options);
+			const movedFocus = target.ownerDocument.activeElement === target;
+			if (!hadTabIndex) {
+				const restoreTabIndex = () => target.removeAttribute("tabindex");
+				if (movedFocus) target.addEventListener("blur", restoreTabIndex, { once: true });
+				else restoreTabIndex();
+			}
+			return {
+				target,
+				focused: movedFocus
+			};
+		}
+		__expose({
+			element,
+			focus,
+			focused,
+			focusTarget,
+			getTarget,
+			href: renderedHref,
+			state,
+			targetId,
+			unavailable
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent("a"), mergeProps({
+				id: unref(linkId),
+				ref_key: "element",
+				ref: element
+			}, anchorAttributes.value, {
+				"aria-disabled": unavailable.value ? "true" : void 0,
+				tabindex: unavailable.value ? -1 : void 0,
+				"data-vize-ui": "skip-link",
+				part: "root",
+				"data-state": state.value,
+				"data-target-id": targetId.value,
+				"data-unavailable": unavailable.value ? "true" : void 0,
+				onClick,
+				onFocus,
+				onBlur
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)]),
+				_: 3
+			}, 16, [
+				"id",
+				"aria-disabled",
+				"tabindex",
+				"data-state",
+				"data-target-id",
+				"data-unavailable"
+			]);
+		};
+	}
+}), [["__scopeId", "data-v-9158cf4f"]]);
+//#endregion
+export { skip_link_default as t };