@vizejs/ui 0.302.0

package/dist/_plugin-vue_export-helper-BVN2DL-U.mjs

@@ -0,0 +1,8 @@
+//#region \0plugin-vue:export-helper
+var _plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+//#endregion
+export { _plugin_vue_export_helper_default as t };

package/dist/button-BcfUlpr_.mjs

@@ -0,0 +1,126 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { computed, createBlock, defineComponent, openBlock, renderSlot, resolveDynamicComponent, useTemplateRef, withCtx } from "vue";
+//#region src/button-keyboard.ts
+/**
+* Resolve native-equivalent activation timing for a non-native button.
+*
+* Enter activates on keydown. Space prevents scrolling on keydown and
+* activates on keyup, matching the interaction users expect from a button.
+*/
+function getButtonKeyboardAction(key, phase) {
+	if (key === "Enter") return phase === "keydown" ? "activate" : "ignore";
+	if (key === " ") return phase === "keydown" ? "prevent" : "activate";
+	return "ignore";
+}
+//#endregion
+//#region src/ActionButton.vue
+var ActionButton_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "ActionButton",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "button"
+		},
+		native: {
+			type: Boolean,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false,
+			default: "button"
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		loading: {
+			type: Boolean,
+			required: false,
+			default: false
+		}
+	},
+	emits: ["press"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const element = useTemplateRef("element");
+		const isNativeButton = computed(() => __props.native ?? __props.as === "button");
+		const unavailable = computed(() => __props.disabled || __props.loading);
+		const tabIndex = computed(() => {
+			if (isNativeButton.value) return void 0;
+			return __props.disabled ? -1 : 0;
+		});
+		function onClick(event) {
+			if (unavailable.value) {
+				event.preventDefault();
+				event.stopImmediatePropagation();
+				return;
+			}
+			emit("press", event);
+		}
+		function onKeyboard(event, phase) {
+			if (isNativeButton.value) return;
+			const action = getButtonKeyboardAction(event.key, phase);
+			if (action === "ignore") return;
+			event.preventDefault();
+			if (unavailable.value) {
+				event.stopImmediatePropagation();
+				return;
+			}
+			if (action === "activate" && event.currentTarget instanceof HTMLElement) event.currentTarget.click();
+		}
+		function onKeydown(event) {
+			onKeyboard(event, "keydown");
+		}
+		function onKeyup(event) {
+			onKeyboard(event, "keyup");
+		}
+		/** Move focus to the rendered control when it exposes a focus method. */
+		function focus(options) {
+			focusTarget(element.value, options);
+		}
+		function focusTarget(target, options) {
+			if (typeof target === "object" && target !== null && "focus" in target && typeof target.focus === "function") target.focus(options);
+		}
+		__expose({
+			element,
+			focus
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), {
+				ref_key: "element",
+				ref: element,
+				type: isNativeButton.value ? __props.type : void 0,
+				disabled: isNativeButton.value ? __props.disabled : void 0,
+				role: isNativeButton.value ? void 0 : "button",
+				tabindex: tabIndex.value,
+				"aria-disabled": unavailable.value && (!isNativeButton.value || __props.loading) ? "true" : void 0,
+				"aria-busy": __props.loading ? "true" : void 0,
+				"data-vize-ui": "button",
+				"data-state": __props.disabled ? "disabled" : __props.loading ? "loading" : "idle",
+				onClick,
+				onKeydown,
+				onKeyup
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", {
+					disabled: __props.disabled,
+					loading: __props.loading,
+					unavailable: unavailable.value
+				}, void 0, true)]),
+				_: 3
+			}, 40, [
+				"type",
+				"disabled",
+				"role",
+				"tabindex",
+				"aria-disabled",
+				"aria-busy",
+				"data-state"
+			]);
+		};
+	}
+}), [["__scopeId", "data-v-0ffc2dd9"]]);
+//#endregion
+export { getButtonKeyboardAction as n, ActionButton_default as t };

package/dist/button-D7sM9Xmj.d.mts

@@ -0,0 +1,75 @@
+import { n as PrimitiveElement, t as PrimitiveAs } from "./primitive-BtvwikH1.mjs";
+import * as _$vue from "vue";
+
+//#region src/button-keyboard.d.ts
+/** Keyboard event phase used by button activation semantics. */
+type ButtonKeyboardPhase = "keydown" | "keyup";
+/** Action required to emulate a native button for one keyboard event. */
+type ButtonKeyboardAction = "activate" | "prevent" | "ignore";
+/**
+ * Resolve native-equivalent activation timing for a non-native button.
+ *
+ * Enter activates on keydown. Space prevents scrolling on keydown and
+ * activates on keyup, matching the interaction users expect from a button.
+ */
+declare function getButtonKeyboardAction(key: string, phase: ButtonKeyboardPhase): ButtonKeyboardAction;
+//#endregion
+//#region src/ActionButton.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Native element, custom element, or component to render.
+   *
+   * @default "button"
+   */
+  readonly as?: PrimitiveAs;
+  /**
+   * Whether the rendered target already implements native button semantics.
+   *
+   * @default true when `as` is "button"; otherwise false
+   */
+  readonly native?: boolean;
+  /**
+   * Native button submission behavior.
+   *
+   * @default "button"
+   */
+  readonly type?: "button" | "reset" | "submit";
+  /**
+   * Remove the control from activation and sequential keyboard focus.
+   *
+   * @default false
+   */
+  readonly disabled?: boolean;
+  /**
+   * Announce in-progress work and prevent repeated activation while preserving focus.
+   *
+   * @default false
+   */
+  readonly loading?: boolean;
+};
+type __VLS_Slots = {
+  default(props: {
+    readonly disabled: boolean;
+    readonly loading: boolean;
+    readonly unavailable: boolean;
+  }): unknown;
+};
+/** Move focus to the rendered control when it exposes a focus method. */
+declare function focus(options?: FocusOptions): void;
+declare const __VLS_base: _$vue.DefineComponent<__VLS_Props, {
+  element: Readonly<_$vue.ShallowRef<PrimitiveElement | null>>;
+  focus: typeof focus;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+  press: (event: MouseEvent) => any;
+}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{
+  onPress?: (event: MouseEvent) => any;
+}>, {}, {}, {}, {}, 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 { getButtonKeyboardAction as i, ButtonKeyboardAction as n, ButtonKeyboardPhase as r, _default as t };

package/dist/button.d.mts

@@ -0,0 +1,2 @@
+import { i as getButtonKeyboardAction, n as ButtonKeyboardAction, r as ButtonKeyboardPhase, t as _default } from "./button-D7sM9Xmj.mjs";
+export { _default as Button, ButtonKeyboardAction, ButtonKeyboardPhase, getButtonKeyboardAction };

package/dist/button.mjs

@@ -0,0 +1,2 @@
+import { n as getButtonKeyboardAction, t as ActionButton_default } from "./button-BcfUlpr_.mjs";
+export { ActionButton_default as Button, getButtonKeyboardAction };

package/dist/checkbox--QJ6FhT4.mjs

@@ -0,0 +1,118 @@
+import { useControllableState } from "./controllable-state.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { computed, createElementBlock, defineComponent, nextTick, openBlock, unref, useTemplateRef, watch, watchEffect } from "vue";
+//#region src/checkbox-state.ts
+/** Resolve the visual state while giving the mixed state precedence. */
+function getCheckboxState(checked, indeterminate) {
+	if (indeterminate) return "indeterminate";
+	return checked ? "checked" : "unchecked";
+}
+//#endregion
+//#region src/CheckboxControl.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"checked",
+	"disabled",
+	"aria-label",
+	"aria-checked",
+	"data-state"
+];
+//#endregion
+//#region src/CheckboxControl.vue
+var CheckboxControl_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "CheckboxControl",
+	props: {
+		modelValue: {
+			type: Boolean,
+			required: false
+		},
+		defaultChecked: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		indeterminate: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		ariaLabel: {
+			type: String,
+			required: false
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"update:indeterminate",
+		"change"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const element = useTemplateRef("element");
+		const state = useControllableState({
+			value: () => __props.modelValue,
+			defaultValue: () => __props.defaultChecked,
+			onChange: (value) => emit("update:modelValue", value)
+		});
+		const checked = state.value;
+		const visualState = computed(() => getCheckboxState(checked.value, __props.indeterminate));
+		function syncNativeState() {
+			if (element.value === null) return;
+			element.value.checked = checked.value;
+			element.value.indeterminate = __props.indeterminate;
+		}
+		watchEffect(syncNativeState);
+		watch(element, (input, _previous, onCleanup) => {
+			const form = input?.form;
+			if (form === void 0 || form === null) return;
+			const onReset = () => {
+				if (!state.controlled.value) state.reset();
+				nextTick(syncNativeState);
+			};
+			form.addEventListener("reset", onReset);
+			onCleanup(() => form.removeEventListener("reset", onReset));
+		}, {
+			flush: "post",
+			immediate: true
+		});
+		function onChange(event) {
+			if (!(event.currentTarget instanceof HTMLInputElement)) return;
+			const next = event.currentTarget.checked;
+			state.set(next);
+			if (__props.indeterminate) emit("update:indeterminate", false);
+			emit("change", next, event);
+			nextTick(syncNativeState);
+		}
+		/** Move focus to the native checkbox. */
+		function focus(options) {
+			element.value?.focus(options);
+		}
+		__expose({
+			element,
+			checked,
+			focus,
+			reset: state.reset,
+			setChecked: state.set
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("input", {
+				ref_key: "element",
+				ref: element,
+				type: "checkbox",
+				checked: unref(checked),
+				disabled: __props.disabled,
+				"aria-label": __props.ariaLabel,
+				"aria-checked": __props.indeterminate ? "mixed" : unref(checked),
+				"data-vize-ui": "checkbox",
+				"data-state": visualState.value,
+				onChange
+			}, null, 40, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-09fed76b"]]);
+//#endregion
+export { getCheckboxState as n, CheckboxControl_default as t };

package/dist/checkbox-DkwZFC80.d.mts

@@ -0,0 +1,62 @@
+import { r as StateUpdate } from "./controllable-state-DXsYJ3yl.mjs";
+import * as _$vue from "vue";
+
+//#region src/checkbox-state.d.ts
+/** Visual state exposed by the Checkbox Native CSS contract. */
+type CheckboxState = "checked" | "unchecked" | "indeterminate";
+/** Resolve the visual state while giving the mixed state precedence. */
+declare function getCheckboxState(checked: boolean, indeterminate: boolean): CheckboxState;
+//#endregion
+//#region src/CheckboxControl.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Controlled checked value. `undefined` selects uncontrolled behavior.
+   *
+   * @default undefined
+   */
+  readonly modelValue?: boolean;
+  /**
+   * Initial unchecked or checked state for uncontrolled use.
+   *
+   * @default false
+   */
+  readonly defaultChecked?: boolean;
+  /**
+   * Render and announce a mixed checked state.
+   *
+   * @default false
+   */
+  readonly indeterminate?: boolean;
+  /**
+   * Disable interaction and native form submission.
+   *
+   * @default false
+   */
+  readonly disabled?: boolean;
+  /**
+   * Accessible name when no associated label supplies one.
+   *
+   * @default undefined
+   */
+  readonly ariaLabel?: string;
+};
+/** Move focus to the native checkbox. */
+declare function focus(options?: FocusOptions): void;
+declare const __VLS_export: _$vue.DefineComponent<__VLS_Props, {
+  element: Readonly<_$vue.ShallowRef<HTMLInputElement | null>>;
+  checked: _$vue.ComputedRef<boolean>;
+  focus: typeof focus;
+  reset: () => boolean;
+  setChecked: (update: StateUpdate<boolean>) => boolean;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+  "update:modelValue": (value: boolean) => any;
+  "update:indeterminate": (value: boolean) => any;
+  change: (value: boolean, nativeEvent: Event) => any;
+}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{
+  "onUpdate:modelValue"?: (value: boolean) => any;
+  "onUpdate:indeterminate"?: (value: boolean) => any;
+  onChange?: (value: boolean, nativeEvent: Event) => any;
+}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { CheckboxState as n, getCheckboxState as r, _default as t };

package/dist/checkbox.d.mts

@@ -0,0 +1,2 @@
+import { n as CheckboxState, r as getCheckboxState, t as _default } from "./checkbox-DkwZFC80.mjs";
+export { _default as Checkbox, CheckboxState, getCheckboxState };

package/dist/checkbox.mjs

@@ -0,0 +1,2 @@
+import { n as getCheckboxState, t as CheckboxControl_default } from "./checkbox--QJ6FhT4.mjs";
+export { CheckboxControl_default as Checkbox, getCheckboxState };

package/dist/context.d.mts

@@ -0,0 +1,25 @@
+import { InjectionKey } from "vue";
+
+//#region src/context.d.ts
+/** A typed provider and consumer contract for one component family. */
+interface ComponentContext<Value> {
+  /** Human-readable context name used by diagnostics and developer tools. */
+  readonly name: string;
+  /** Public injection key for application-level adapters and test harnesses. */
+  readonly key: InjectionKey<Value>;
+  /** Provides a value from component setup and returns that same value. */
+  readonly provide: (value: Value) => Value;
+  /** Reads the nearest value or throws a stable missing-provider diagnostic. */
+  readonly use: () => Value;
+  /** Reads the nearest value when the provider is intentionally optional. */
+  readonly useOptional: () => Value | undefined;
+}
+/**
+ * Creates an immutable typed context for a compound component family.
+ *
+ * A private sentinel distinguishes a missing provider from a provider whose
+ * value is explicitly `undefined`.
+ */
+declare function createContext<Value>(name: string): ComponentContext<Value>;
+//#endregion
+export { ComponentContext, createContext };

package/dist/context.mjs

@@ -0,0 +1,35 @@
+import { inject, provide } from "vue";
+//#region src/context.ts
+const missingContext = Symbol("missing component context");
+/**
+* Creates an immutable typed context for a compound component family.
+*
+* A private sentinel distinguishes a missing provider from a provider whose
+* value is explicitly `undefined`.
+*/
+function createContext(name) {
+	const contextName = name.trim();
+	if (contextName.length === 0) throw new Error("VIZE_UI_CONTEXT_NAME: context name must not be empty");
+	const key = Symbol(contextName);
+	const internalKey = key;
+	const read = () => inject(internalKey, missingContext);
+	return Object.freeze({
+		name: contextName,
+		key,
+		provide: (value) => {
+			provide(key, value);
+			return value;
+		},
+		use: () => {
+			const value = read();
+			if (value === missingContext) throw new Error(`VIZE_UI_CONTEXT_MISSING: ${contextName} requires a matching provider`);
+			return value;
+		},
+		useOptional: () => {
+			const value = read();
+			return value === missingContext ? void 0 : value;
+		}
+	});
+}
+//#endregion
+export { createContext };

package/dist/controllable-state-DXsYJ3yl.d.mts

@@ -0,0 +1,48 @@
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+
+//#region src/controllable-state.d.ts
+/** Direct value or updater accepted by {@link ControllableState.set}. */
+type StateUpdate<Value> = Value | ((previous: Value) => Value);
+/** Options for {@link useControllableState}. */
+interface ControllableStateOptions<Value> {
+  /**
+   * Reactive controlled value. `undefined` selects uncontrolled behavior.
+   *
+   * @default undefined
+   */
+  readonly value?: MaybeRefOrGetter<Value | undefined>;
+  /** Initial value and the value restored by {@link ControllableState.reset}. */
+  readonly defaultValue: MaybeRefOrGetter<Value>;
+  /**
+   * Equality comparison used to suppress redundant updates.
+   *
+   * @default Object.is
+   */
+  readonly equals?: (left: Value, right: Value) => boolean;
+  /**
+   * Called after a distinct state change is requested.
+   *
+   * @default undefined
+   */
+  readonly onChange?: (value: Value, previous: Value) => void;
+}
+/** Reactive state that can move safely between controlled and uncontrolled use. */
+interface ControllableState<Value> {
+  /** Current controlled or internal value. */
+  readonly value: ComputedRef<Value>;
+  /** Whether the reactive source currently controls the value. */
+  readonly controlled: ComputedRef<boolean>;
+  /** Request an update and report whether it differs from the current value. */
+  readonly set: (update: StateUpdate<Value>) => boolean;
+  /** Request the current default value and report whether it changed. */
+  readonly reset: () => boolean;
+}
+/**
+ * Create one state contract for controlled props and internal state.
+ *
+ * The last controlled value is retained if the source becomes uncontrolled,
+ * preventing an abrupt jump back to the initial default.
+ */
+declare function useControllableState<Value>(options: ControllableStateOptions<Value>): ControllableState<Value>;
+//#endregion
+export { useControllableState as i, ControllableStateOptions as n, StateUpdate as r, ControllableState as t };

package/dist/controllable-state.d.mts

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

package/dist/controllable-state.mjs

@@ -0,0 +1,36 @@
+import { computed, shallowRef, toValue, watch } from "vue";
+//#region src/controllable-state.ts
+/**
+* Create one state contract for controlled props and internal state.
+*
+* The last controlled value is retained if the source becomes uncontrolled,
+* preventing an abrupt jump back to the initial default.
+*/
+function useControllableState(options) {
+	const internal = shallowRef(toValue(options.defaultValue));
+	const controlledValue = () => options.value === void 0 ? void 0 : toValue(options.value);
+	const controlled = computed(() => controlledValue() !== void 0);
+	const value = computed(() => controlledValue() ?? internal.value);
+	watch(controlledValue, (next) => {
+		if (next !== void 0) internal.value = next;
+	}, {
+		flush: "sync",
+		immediate: true
+	});
+	const set = (update) => {
+		const previous = value.value;
+		const next = typeof update === "function" ? update(previous) : update;
+		if ((options.equals ?? Object.is)(previous, next)) return false;
+		if (!controlled.value) internal.value = next;
+		options.onChange?.(next, previous);
+		return true;
+	};
+	return {
+		value,
+		controlled,
+		set,
+		reset: () => set(toValue(options.defaultValue))
+	};
+}
+//#endregion
+export { useControllableState };

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+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 { 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 };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { n as getCheckboxState, t as CheckboxControl_default } from "./checkbox--QJ6FhT4.mjs";
+import { useControllableState } from "./controllable-state.mjs";
+import { createContext } from "./context.mjs";
+import { n as getButtonKeyboardAction, t as ActionButton_default } from "./button-BcfUlpr_.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 };

package/dist/media-pdf.d.mts

@@ -0,0 +1,2 @@
+import { n as createPDFSource, t as CreatePDFSourceOptions } from "./pdf-source-COxN3A1l.mjs";
+export { type CreatePDFSourceOptions, createPDFSource };

package/dist/media-pdf.mjs

@@ -0,0 +1,2 @@
+import { t as createPDFSource } from "./pdf-source-C52YE8tp.mjs";
+export { createPDFSource };

package/dist/media-source.d.mts

@@ -0,0 +1,28 @@
+//#region src/media-source.d.ts
+/** Media resource category used to constrain inline data. */
+type MediaSourceKind = "audio" | "image" | "pdf" | "stream" | "track" | "video";
+/** Options for {@link normalizeMediaSource}. */
+interface NormalizeMediaSourceOptions {
+  /** Expected media resource category. */
+  readonly kind: MediaSourceKind;
+  /**
+   * Permits an unencrypted HTTP resource for local development.
+   *
+   * @default false
+   */
+  readonly allowInsecure?: boolean;
+}
+/**
+ * Validates and normalizes a media resource reference.
+ *
+ * Relative references, network-relative references, encrypted remote URLs,
+ * object URLs, and category-matched inline data are accepted. Unencrypted
+ * remote URLs require an explicit opt-in. Unknown and script-capable schemes
+ * are rejected.
+ *
+ * @throws {TypeError} When the resource is empty, malformed, unsafe, or does
+ * not match the requested media category.
+ */
+declare function normalizeMediaSource(source: string, options: NormalizeMediaSourceOptions): string;
+//#endregion
+export { MediaSourceKind, NormalizeMediaSourceOptions, normalizeMediaSource };

package/dist/media-source.mjs

@@ -0,0 +1,67 @@
+//#region src/media-source.ts
+const SOURCE_KINDS = new Set([
+	"audio",
+	"image",
+	"pdf",
+	"stream",
+	"track",
+	"video"
+]);
+const SCHEME = /^([a-z][a-z\d+.-]*):/i;
+const BASE64_PAYLOAD = /^(?:[a-z\d+/]{4})*(?:[a-z\d+/]{2}==|[a-z\d+/]{3}=)?$/i;
+const BINARY_MEDIA_TYPE = /^(audio|image|video)\/([a-z\d][a-z\d.+-]*)$/i;
+const INVALID_PERCENT_ESCAPE = /%(?![a-f\d]{2})/i;
+/**
+* Validates and normalizes a media resource reference.
+*
+* Relative references, network-relative references, encrypted remote URLs,
+* object URLs, and category-matched inline data are accepted. Unencrypted
+* remote URLs require an explicit opt-in. Unknown and script-capable schemes
+* are rejected.
+*
+* @throws {TypeError} When the resource is empty, malformed, unsafe, or does
+* not match the requested media category.
+*/
+function normalizeMediaSource(source, options) {
+	const kind = options?.kind;
+	if (!SOURCE_KINDS.has(kind)) throw new TypeError(`[VIZE_UI_MEDIA_INVALID_KIND] Unknown media source kind: ${String(kind)}`);
+	if (typeof source !== "string") throw new TypeError("[VIZE_UI_MEDIA_INVALID_SOURCE] Media source must be a string");
+	const normalized = source.trim();
+	if (normalized.length === 0 || containsControlCharacter(normalized)) throw new TypeError("[VIZE_UI_MEDIA_INVALID_SOURCE] Media source must be non-empty and contain no control characters");
+	const scheme = SCHEME.exec(normalized)?.[1]?.toLowerCase();
+	if (scheme === void 0 || scheme === "https" || scheme === "blob") return normalized;
+	if (scheme === "http" && options.allowInsecure === true) return normalized;
+	if (scheme === "data" && isAllowedDataSource(normalized, kind)) return normalized;
+	throw new TypeError(`[VIZE_UI_MEDIA_DISALLOWED_SOURCE] Source is not allowed for ${kind}: ${scheme}`);
+}
+function isAllowedDataSource(source, kind) {
+	if (kind === "stream") return false;
+	const commaIndex = source.indexOf(",");
+	if (commaIndex < 6) return false;
+	const metadata = source.slice(5, commaIndex).toLowerCase();
+	const payload = source.slice(commaIndex + 1);
+	if (payload.length === 0) return false;
+	const segments = metadata.split(";");
+	const mediaType = segments.shift();
+	const isBase64 = segments.at(-1) === "base64";
+	if (isBase64) segments.pop();
+	if (kind === "pdf") return mediaType === "application/pdf" && segments.length === 0 && isBase64 && isValidBase64(payload);
+	if (kind === "track") {
+		const hasValidParameters = segments.length === 0 || segments.length === 1 && segments[0] === "charset=utf-8";
+		if (mediaType !== "text/vtt" || !hasValidParameters) return false;
+		return isBase64 ? isValidBase64(payload) : !INVALID_PERCENT_ESCAPE.test(payload);
+	}
+	return (mediaType === void 0 ? void 0 : BINARY_MEDIA_TYPE.exec(mediaType)?.[1])?.toLowerCase() === kind && segments.length === 0 && isBase64 && isValidBase64(payload);
+}
+function isValidBase64(payload) {
+	return payload.length > 0 && BASE64_PAYLOAD.test(payload);
+}
+function containsControlCharacter(value) {
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code <= 31 || code === 127) return true;
+	}
+	return false;
+}
+//#endregion
+export { normalizeMediaSource };

package/dist/media.d.mts

@@ -0,0 +1,3 @@
+import { MediaSourceKind, NormalizeMediaSourceOptions, normalizeMediaSource } from "./media-source.mjs";
+import { n as createPDFSource, t as CreatePDFSourceOptions } from "./pdf-source-COxN3A1l.mjs";
+export { type CreatePDFSourceOptions, type MediaSourceKind, type NormalizeMediaSourceOptions, createPDFSource, normalizeMediaSource };

package/dist/media.mjs

@@ -0,0 +1,3 @@
+import { normalizeMediaSource } from "./media-source.mjs";
+import { t as createPDFSource } from "./pdf-source-C52YE8tp.mjs";
+export { createPDFSource, normalizeMediaSource };

package/dist/pdf-source-C52YE8tp.mjs

@@ -0,0 +1,23 @@
+import { normalizeMediaSource } from "./media-source.mjs";
+//#region src/pdf-source.ts
+/**
+* Validates a PDF resource and applies a standards-compatible initial page.
+*
+* @throws {TypeError} When the PDF source is unsafe or malformed.
+* @throws {RangeError} When `page` is not a positive safe integer.
+*/
+function createPDFSource(source, options = {}) {
+	const normalized = normalizeMediaSource(source, {
+		kind: "pdf",
+		allowInsecure: options.allowInsecure ?? false
+	});
+	if (options.page === void 0) return normalized;
+	if (!Number.isSafeInteger(options.page) || options.page < 1) throw new RangeError(`[VIZE_UI_MEDIA_INVALID_PDF_PAGE] PDF page must be a positive safe integer; received ${String(options.page)}`);
+	const fragmentIndex = normalized.indexOf("#");
+	const resource = fragmentIndex === -1 ? normalized : normalized.slice(0, fragmentIndex);
+	const parameters = (fragmentIndex === -1 ? "" : normalized.slice(fragmentIndex + 1)).split("&").filter((parameter) => parameter.length > 0 && !parameter.toLowerCase().startsWith("page="));
+	parameters.push(`page=${options.page}`);
+	return `${resource}#${parameters.join("&")}`;
+}
+//#endregion
+export { createPDFSource as t };

package/dist/pdf-source-COxN3A1l.d.mts

@@ -0,0 +1,28 @@
+//#region src/pdf-source.d.ts
+/** Options for {@link createPDFSource}. */
+interface CreatePDFSourceOptions {
+  /**
+   * One-based initial PDF page.
+   *
+   * Existing `page` parameters in the PDF fragment are replaced while other
+   * fragment parameters are preserved.
+   *
+   * @default undefined
+   */
+  readonly page?: number;
+  /**
+   * Permits an unencrypted HTTP resource for local development.
+   *
+   * @default false
+   */
+  readonly allowInsecure?: boolean;
+}
+/**
+ * Validates a PDF resource and applies a standards-compatible initial page.
+ *
+ * @throws {TypeError} When the PDF source is unsafe or malformed.
+ * @throws {RangeError} When `page` is not a positive safe integer.
+ */
+declare function createPDFSource(source: string, options?: CreatePDFSourceOptions): string;
+//#endregion
+export { createPDFSource as n, CreatePDFSourceOptions as t };

package/dist/primitive-BtvwikH1.d.mts

@@ -0,0 +1,32 @@
+import * as _$vue from "vue";
+import { Component, ComponentPublicInstance } from "vue";
+
+//#region src/PrimitiveElement.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Native element, custom element, or component to render.
+   *
+   * @default "div"
+   */
+  readonly as?: PrimitiveAs;
+};
+declare var __VLS_11: string, __VLS_12: {};
+type __VLS_Slots = {} & { [K in NonNullable<typeof __VLS_11>]?: (props: typeof __VLS_12) => any };
+declare const __VLS_base: _$vue.DefineComponent<__VLS_Props, {
+  element: Readonly<_$vue.ShallowRef<PrimitiveElement | null>>;
+}, {}, {}, {}, _$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
+//#region src/primitive.d.ts
+/** Native element, custom element, or component accepted by {@link Primitive}. */
+type PrimitiveAs = string | Component;
+/** Rendered value exposed by {@link Primitive}. */
+type PrimitiveElement = Element | ComponentPublicInstance;
+//#endregion
+export { PrimitiveElement as n, _default as r, PrimitiveAs as t };

package/dist/primitive-DJB7pOf3.mjs

@@ -0,0 +1,34 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { createBlock, createSlots, defineComponent, openBlock, renderList, renderSlot, resolveDynamicComponent, useSlots, useTemplateRef, withCtx } from "vue";
+//#endregion
+//#region src/PrimitiveElement.vue
+var PrimitiveElement_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "PrimitiveElement",
+	props: { as: {
+		type: null,
+		required: false,
+		default: "div"
+	} },
+	setup(__props, { expose: __expose }) {
+		const slots = useSlots();
+		const element = useTemplateRef("element");
+		function getSlotNames() {
+			return Object.keys(slots);
+		}
+		__expose({ element });
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), {
+				ref_key: "element",
+				ref: element,
+				"data-vize-ui": "primitive"
+			}, createSlots({ _: 2 }, [renderList(getSlotNames(), (name) => {
+				return {
+					name,
+					fn: withCtx(() => [renderSlot(_ctx.$slots, name, {}, void 0, true)])
+				};
+			})]), 1536);
+		};
+	}
+}), [["__scopeId", "data-v-6c8b649e"]]);
+//#endregion
+export { PrimitiveElement_default as t };

package/dist/primitive.d.mts

@@ -0,0 +1,2 @@
+import { n as PrimitiveElement, r as _default, t as PrimitiveAs } from "./primitive-BtvwikH1.mjs";
+export { _default as Primitive, PrimitiveAs, PrimitiveElement };

package/dist/primitive.mjs

@@ -0,0 +1,2 @@
+import { t as PrimitiveElement_default } from "./primitive-DJB7pOf3.mjs";
+export { PrimitiveElement_default as Primitive };

package/dist/style.css

@@ -0,0 +1 @@
+[data-vize-ui=visually-hidden][data-v-812b49c6]{clip-path:inset(50%);white-space:nowrap;border:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}

package/dist/visually-hidden-BegtnMng.d.mts

@@ -0,0 +1,19 @@
+import * as _$vue from "vue";
+
+//#region src/VisuallyHidden.vue.d.ts
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: _$vue.DefineComponent<{}, {
+  element: Readonly<_$vue.ShallowRef<HTMLSpanElement | null>>;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, 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 { _default as t };

package/dist/visually-hidden-QENRapzW.mjs

@@ -0,0 +1,21 @@
+import './style.css';
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { createElementBlock, defineComponent, openBlock, renderSlot, useTemplateRef } from "vue";
+//#endregion
+//#region src/VisuallyHidden.vue
+var VisuallyHidden_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "VisuallyHidden",
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		__expose({ element });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", {
+				ref_key: "element",
+				ref: element,
+				"data-vize-ui": "visually-hidden"
+			}, [renderSlot(_ctx.$slots, "default", {}, void 0, true)], 512);
+		};
+	}
+}), [["__scopeId", "data-v-812b49c6"]]);
+//#endregion
+export { VisuallyHidden_default as t };

package/dist/visually-hidden.d.mts

@@ -0,0 +1,2 @@
+import { t as _default } from "./visually-hidden-BegtnMng.mjs";
+export { _default as VisuallyHidden };

package/dist/visually-hidden.mjs

@@ -0,0 +1,2 @@
+import { t as VisuallyHidden_default } from "./visually-hidden-QENRapzW.mjs";
+export { VisuallyHidden_default as VisuallyHidden };

package/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "@vizejs/ui",
+  "version": "0.302.0",
+  "description": "Accessible, headless, Native CSS-first UI primitives",
+  "keywords": [
+    "accessibility",
+    "headless",
+    "type-safe",
+    "vize",
+    "vue"
+  ],
+  "homepage": "https://github.com/ubugeeei-prod/vize",
+  "bugs": {
+    "url": "https://github.com/ubugeeei-prod/vize/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei-prod/vize.git",
+    "directory": "npm/ui/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": [
+    "./dist/*.css"
+  ],
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./button": {
+      "types": "./dist/button.d.mts",
+      "import": "./dist/button.mjs",
+      "default": "./dist/button.mjs"
+    },
+    "./checkbox": {
+      "types": "./dist/checkbox.d.mts",
+      "import": "./dist/checkbox.mjs",
+      "default": "./dist/checkbox.mjs"
+    },
+    "./context": {
+      "types": "./dist/context.d.mts",
+      "import": "./dist/context.mjs",
+      "default": "./dist/context.mjs"
+    },
+    "./controllable-state": {
+      "types": "./dist/controllable-state.d.mts",
+      "import": "./dist/controllable-state.mjs",
+      "default": "./dist/controllable-state.mjs"
+    },
+    "./primitive": {
+      "types": "./dist/primitive.d.mts",
+      "import": "./dist/primitive.mjs",
+      "default": "./dist/primitive.mjs"
+    },
+    "./visually-hidden": {
+      "types": "./dist/visually-hidden.d.mts",
+      "import": "./dist/visually-hidden.mjs",
+      "default": "./dist/visually-hidden.mjs"
+    },
+    "./style.css": "./dist/style.css",
+    "./media": {
+      "types": "./dist/media.d.mts",
+      "import": "./dist/media.mjs",
+      "default": "./dist/media.mjs"
+    },
+    "./media/pdf": {
+      "types": "./dist/media-pdf.d.mts",
+      "import": "./dist/media-pdf.mjs",
+      "default": "./dist/media-pdf.mjs"
+    },
+    "./media/source": {
+      "types": "./dist/media-source.d.mts",
+      "import": "./dist/media-source.mjs",
+      "default": "./dist/media-source.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "lint:sfc": "vp exec node scripts/lint-sfc.ts src",
+    "pretest": "vp pack && pnpm check:size",
+    "test": "vp test run",
+    "check": "vp check src scripts vite.config.ts",
+    "check:fix": "vp check --fix src scripts vite.config.ts",
+    "check:size": "node scripts/check-size.mjs",
+    "fmt": "vp fmt --write src scripts vite.config.ts"
+  },
+  "devDependencies": {
+    "@tsdown/css": "catalog:content",
+    "@types/node": "catalog:typescript",
+    "@vitejs/plugin-vue": "catalog:vite-stack",
+    "@vizejs/native": "workspace:*",
+    "@vizejs/ui-tooling": "workspace:*",
+    "@vue/test-utils": "catalog:vue-stable",
+    "happy-dom": "catalog:testing",
+    "typescript": "catalog:typescript",
+    "vite": "catalog:vite-stack",
+    "vite-plus": "catalog:vite-stack",
+    "vue": "catalog:vue-stable"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}