@vizejs/ui 0.387.0 → 0.389.0

package/dist/live-region-runtime-DVUch8Lu.mjs

@@ -0,0 +1,62 @@
+import { getCurrentScope, nextTick, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
+//#region src/families/accessibility/live-region/live-region-runtime.ts
+const invalidOptionDiagnostic = "VIZE_UI_LIVE_REGION_OPTION";
+const disposedDiagnostic = "VIZE_UI_LIVE_REGION_DISPOSED";
+const setupDiagnostic = "VIZE_UI_LIVE_REGION_SETUP";
+const politenessValues = new Set(["assertive", "polite"]);
+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 validateOptions(options) {
+	if (typeof options.politeness !== "function") readPoliteness(options.politeness, "polite");
+}
+/** Create an SSR-safe announcement queue for one live region. */
+function createLiveRegion(options = {}) {
+	validateOptions(options);
+	const message = shallowRef("");
+	const politeness = shallowRef(readPoliteness(options.politeness, "polite"));
+	let disposed = false;
+	let token = 0;
+	const assertAlive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	return Object.freeze({
+		message: shallowReadonly(message),
+		politeness: shallowReadonly(politeness),
+		announce: (text, nextPoliteness) => {
+			assertAlive();
+			if (typeof text !== "string") throw new TypeError(`${invalidOptionDiagnostic}: announcement text must be a string`);
+			if (nextPoliteness !== void 0) politeness.value = readPoliteness(nextPoliteness, "polite");
+			else politeness.value = readPoliteness(options.politeness, "polite");
+			const generation = ++token;
+			message.value = "";
+			nextTick(() => {
+				if (disposed || generation !== token) return;
+				message.value = text;
+			});
+		},
+		clear: () => {
+			assertAlive();
+			token += 1;
+			message.value = "";
+		},
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			token += 1;
+			message.value = "";
+		}
+	});
+}
+/** Create a live-region announcer disposed with the current Vue effect scope. */
+function useLiveRegion(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createLiveRegion(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useLiveRegion as n, createLiveRegion as t };

package/dist/live-region.d.mts

@@ -0,0 +1,2 @@
+import { a as LiveRegionOptions, i as LiveRegionController, n as createLiveRegion, o as LiveRegionPoliteness, r as useLiveRegion, t as _default } from "./live-region-G1iobPK5.mjs";
+export { _default as LiveRegion, type LiveRegionController, type LiveRegionOptions, type LiveRegionPoliteness, createLiveRegion, useLiveRegion };

package/dist/live-region.mjs

@@ -0,0 +1,3 @@
+import { n as useLiveRegion, t as createLiveRegion } from "./live-region-runtime-DVUch8Lu.mjs";
+import { t as live_region_default } from "./live-region-DYSpwCTk.mjs";
+export { live_region_default as LiveRegion, createLiveRegion, useLiveRegion };

package/dist/locale-DzWqhJZs.mjs

@@ -0,0 +1,206 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { createContext } from "./context.mjs";
+import { computed, createElementBlock, defineComponent, getCurrentInstance, openBlock, reactive, renderSlot, toValue, watchEffect } from "vue";
+//#region src/families/i18n/locale/locale-runtime.ts
+const fallbackLocaleValue = "en-US";
+const setupDiagnostic = "VIZE_UI_LOCALE_SETUP";
+const defaultSearchCollatorOptions = Object.freeze({
+	sensitivity: "base",
+	usage: "search"
+});
+/** Typed locale context for application and component subtrees. */
+const localeContext = createContext("Locale");
+function fallbackLocale() {
+	if (typeof document === "undefined") return fallbackLocaleValue;
+	return resolveLocale(document.documentElement.lang);
+}
+function fallbackDirection() {
+	if (typeof document === "undefined") return "ltr";
+	return document.documentElement.dir === "rtl" ? "rtl" : "ltr";
+}
+/** Resolve a BCP 47 locale, or `en-US`. */
+function resolveLocale(locale) {
+	const candidate = locale.trim();
+	if (candidate.length === 0) return fallbackLocaleValue;
+	try {
+		return Intl.getCanonicalLocales(candidate)[0] ?? fallbackLocaleValue;
+	} catch {
+		return fallbackLocaleValue;
+	}
+}
+/**
+* Resolve `auto` direction from `Intl.Locale` when the engine exposes it.
+*/
+function resolveDirection(direction, locale) {
+	if (direction === "ltr" || direction === "rtl") return direction;
+	try {
+		if (new Intl.Locale(locale).textInfo?.direction === "rtl") return "rtl";
+	} catch {}
+	return "ltr";
+}
+/** Create a number formatter. */
+function resolveNumberFormatter(locale, options) {
+	return new Intl.NumberFormat(resolveLocale(locale), options);
+}
+/** Create a date-time formatter. */
+function resolveDateTimeFormatter(locale, options) {
+	return new Intl.DateTimeFormat(resolveLocale(locale), options);
+}
+/** Create a list formatter. */
+function resolveListFormatter(locale, options) {
+	return new Intl.ListFormat(resolveLocale(locale), options);
+}
+/** Create a relative-time formatter. */
+function resolveRelativeTimeFormatter(locale, options) {
+	return new Intl.RelativeTimeFormat(resolveLocale(locale), options);
+}
+/** Create a display-name formatter. */
+function resolveDisplayNames(locale, options) {
+	return new Intl.DisplayNames(resolveLocale(locale), options);
+}
+/** Create a collator. */
+function resolveCollator(locale, options) {
+	return new Intl.Collator(resolveLocale(locale), options);
+}
+/** Create a search collator with stable typeahead defaults. */
+function resolveSearchCollator(locale, options) {
+	return resolveCollator(locale, {
+		...defaultSearchCollatorOptions,
+		...options
+	});
+}
+/** Read the nearest locale, or the document/SSR fallback. */
+function useLocale() {
+	if (!getCurrentInstance()) throw new Error(`${setupDiagnostic}: use inside component setup`);
+	const provided = localeContext.useOptional();
+	return computed(() => provided?.locale ?? fallbackLocale());
+}
+/** Read the nearest resolved writing direction, or the document/SSR fallback. */
+function useDirection() {
+	if (!getCurrentInstance()) throw new Error(`${setupDiagnostic}: use inside component setup`);
+	const provided = localeContext.useOptional();
+	return computed(() => provided?.direction ?? fallbackDirection());
+}
+/** Read the nearest locale and memoize a number formatter. */
+function useNumberFormatter(options) {
+	const locale = useLocale();
+	return computed(() => resolveNumberFormatter(locale.value, toValue(options)));
+}
+/** Read the nearest locale and memoize a date-time formatter. */
+function useDateTimeFormatter(options) {
+	const locale = useLocale();
+	return computed(() => resolveDateTimeFormatter(locale.value, toValue(options)));
+}
+/** Read the nearest locale and memoize a list formatter. */
+function useListFormatter(options) {
+	const locale = useLocale();
+	return computed(() => resolveListFormatter(locale.value, toValue(options)));
+}
+/** Read the nearest locale and memoize a relative-time formatter. */
+function useRelativeTimeFormatter(options) {
+	const locale = useLocale();
+	return computed(() => resolveRelativeTimeFormatter(locale.value, toValue(options)));
+}
+/** Read the nearest locale and memoize a display-name formatter. */
+function useDisplayNames(options) {
+	const locale = useLocale();
+	return computed(() => resolveDisplayNames(locale.value, toValue(options)));
+}
+/** Read the nearest locale and memoize a collator. */
+function useCollator(options) {
+	const locale = useLocale();
+	return computed(() => resolveCollator(locale.value, toValue(options)));
+}
+/** Read the nearest locale and memoize a search collator. */
+function useSearchCollator(options) {
+	const locale = useLocale();
+	return computed(() => resolveSearchCollator(locale.value, toValue(options)));
+}
+//#endregion
+//#region src/families/i18n/locale/locale-text.ts
+/**
+* Normalize authored, extracted, or searched text without applying a locale.
+*
+* Unicode is normalized to NFC and every whitespace run becomes one ASCII
+* space. Locale-sensitive equality remains the responsibility of a collator.
+*/
+function normalizeLocaleText(value) {
+	return value.normalize("NFC").trim().replace(/\s+/gu, " ");
+}
+/** Whether a candidate text starts with a query under locale-aware comparison. */
+function localeTextStartsWith(candidate, query, collator) {
+	const normalizedCandidate = normalizeLocaleText(candidate);
+	const normalizedQuery = normalizeLocaleText(query);
+	let codeUnitLength = 0;
+	for (const character of normalizedCandidate) {
+		codeUnitLength += character.length;
+		if (collator.compare(normalizedCandidate.slice(0, codeUnitLength), normalizedQuery) === 0) return true;
+	}
+	return normalizedQuery.length === 0;
+}
+/** Whether a candidate text contains a query under locale-aware comparison. */
+function localeTextContains(candidate, query, collator) {
+	const normalizedCandidate = normalizeLocaleText(candidate);
+	const normalizedQuery = normalizeLocaleText(query);
+	if (normalizedQuery.length === 0) return true;
+	for (const start of codeUnitOffsets(normalizedCandidate)) if (localeTextStartsWith(normalizedCandidate.slice(start), normalizedQuery, collator)) return true;
+	return false;
+}
+/** Match normalized text with a locale-aware comparator. */
+function localeTextMatches(candidate, query, options) {
+	const match = options.match ?? "prefix";
+	if (match === "exact") return options.collator.compare(normalizeLocaleText(candidate), normalizeLocaleText(query)) === 0;
+	if (match === "contains") return localeTextContains(candidate, query, options.collator);
+	return localeTextStartsWith(candidate, query, options.collator);
+}
+function* codeUnitOffsets(value) {
+	let offset = 0;
+	yield offset;
+	for (const character of value) {
+		offset += character.length;
+		if (offset < value.length) yield offset;
+	}
+}
+//#endregion
+//#region src/families/i18n/locale/locale-provider.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["lang", "dir"];
+//#endregion
+//#region src/families/i18n/locale/locale-provider.vue
+var locale_provider_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "locale-provider",
+	props: {
+		locale: {
+			type: String,
+			required: false,
+			default: "en-US"
+		},
+		direction: {
+			type: String,
+			required: false,
+			default: "ltr"
+		}
+	},
+	setup(__props) {
+		const value = reactive({
+			locale: "en-US",
+			direction: "ltr"
+		});
+		watchEffect(() => {
+			value.locale = resolveLocale(__props.locale);
+			value.direction = resolveDirection(__props.direction, value.locale);
+		});
+		localeContext.provide(value);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-vize-ui": "locale",
+				lang: value.locale,
+				dir: value.direction
+			}, [renderSlot(_ctx.$slots, "default", {
+				locale: value.locale,
+				direction: value.direction
+			}, void 0, true)], 8, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-d8cdfe77"]]);
+//#endregion
+export { useRelativeTimeFormatter as C, useNumberFormatter as S, useDateTimeFormatter as _, normalizeLocaleText as a, useListFormatter as b, resolveDateTimeFormatter as c, resolveListFormatter as d, resolveLocale as f, useCollator as g, resolveSearchCollator as h, localeTextStartsWith as i, resolveDirection as l, resolveRelativeTimeFormatter as m, localeTextContains as n, localeContext as o, resolveNumberFormatter as p, localeTextMatches as r, resolveCollator as s, locale_provider_default as t, resolveDisplayNames as u, useDirection as v, useSearchCollator as w, useLocale as x, useDisplayNames as y };

package/dist/locale.d.mts

@@ -0,0 +1,2 @@
+import { $ as LocaleRelativeTimeFormatterOptions, B as localeTextContains, G as LocaleCollatorOptions, H as localeTextStartsWith, J as LocaleDisplayNamesOptionsInput, K as LocaleDateTimeFormatterOptions, L as _default, Q as LocaleNumberFormatterOptions, R as LocaleTextMatchMode, U as normalizeLocaleText, V as localeTextMatches, W as DirectionPreference, X as LocaleFormatterOptionsInput, Y as LocaleDisplayNamesType, Z as LocaleListFormatterOptions, _t as useLocale, at as resolveDirection, bt as useSearchCollator, ct as resolveLocale, dt as resolveSearchCollator, et as LocaleValue, ft as useCollator, gt as useListFormatter, ht as useDisplayNames, it as resolveDateTimeFormatter, lt as resolveNumberFormatter, mt as useDirection, nt as localeContext, ot as resolveDisplayNames, pt as useDateTimeFormatter, q as LocaleDisplayNamesOptions, rt as resolveCollator, st as resolveListFormatter, tt as TextDirection, ut as resolveRelativeTimeFormatter, vt as useNumberFormatter, yt as useRelativeTimeFormatter, z as LocaleTextMatchOptions } from "./announcer-CuBryPW9.mjs";
+export { type DirectionPreference, type LocaleCollatorOptions, type LocaleDateTimeFormatterOptions, type LocaleDisplayNamesOptions, type LocaleDisplayNamesOptionsInput, type LocaleDisplayNamesType, type LocaleFormatterOptionsInput, type LocaleListFormatterOptions, type LocaleNumberFormatterOptions, _default as LocaleProvider, type LocaleRelativeTimeFormatterOptions, type LocaleTextMatchMode, type LocaleTextMatchOptions, type LocaleValue, type TextDirection, localeContext, localeTextContains, localeTextMatches, localeTextStartsWith, normalizeLocaleText, resolveCollator, resolveDateTimeFormatter, resolveDirection, resolveDisplayNames, resolveListFormatter, resolveLocale, resolveNumberFormatter, resolveRelativeTimeFormatter, resolveSearchCollator, useCollator, useDateTimeFormatter, useDirection, useDisplayNames, useListFormatter, useLocale, useNumberFormatter, useRelativeTimeFormatter, useSearchCollator };

package/dist/locale.mjs

@@ -0,0 +1,2 @@
+import { C as useRelativeTimeFormatter, S as useNumberFormatter, _ as useDateTimeFormatter, a as normalizeLocaleText, b as useListFormatter, c as resolveDateTimeFormatter, d as resolveListFormatter, f as resolveLocale, g as useCollator, h as resolveSearchCollator, i as localeTextStartsWith, l as resolveDirection, m as resolveRelativeTimeFormatter, n as localeTextContains, o as localeContext, p as resolveNumberFormatter, r as localeTextMatches, s as resolveCollator, t as locale_provider_default, u as resolveDisplayNames, v as useDirection, w as useSearchCollator, x as useLocale, y as useDisplayNames } from "./locale-DzWqhJZs.mjs";
+export { locale_provider_default as LocaleProvider, localeContext, localeTextContains, localeTextMatches, localeTextStartsWith, normalizeLocaleText, resolveCollator, resolveDateTimeFormatter, resolveDirection, resolveDisplayNames, resolveListFormatter, resolveLocale, resolveNumberFormatter, resolveRelativeTimeFormatter, resolveSearchCollator, useCollator, useDateTimeFormatter, useDirection, useDisplayNames, useListFormatter, useLocale, useNumberFormatter, useRelativeTimeFormatter, useSearchCollator };

package/dist/{long-press-cll6z2K9.d.mts → long-press-DyYxp191.d.mts}

@@ -1,7 +1,7 @@
-import { n as PressEvent, o as PressPointerType, s as PressProps } from "./press-types-CNqStzJf.mjs";
+import { n as PressEvent, o as PressPointerType, s as PressProps } from "./press-types-DfTNpqby.mjs";
 import { MaybeRefOrGetter, ShallowRef } from "vue";
 
-//#region src/long-press-types.d.ts
+//#region src/families/interaction/long-press/long-press-types.d.ts
 /** Pointing-device families eligible to start a long press. */
 type LongPressPointerType = Extract<PressPointerType, "mouse" | "pen" | "pointer" | "touch">;
 /** Lifecycle notification emitted by a long-press controller. */
@@ -96,7 +96,7 @@ interface LongPressController {
   readonly dispose: () => void;
 }
 //#endregion
-//#region src/long-press.d.ts
+//#region src/families/interaction/long-press/long-press.d.ts
 /** Create an SSR-safe long-press recognizer for one host element. */
 declare function createLongPress(options?: LongPressOptions): LongPressController;
 /** Create a long-press recognizer disposed with the current Vue effect scope. */

package/dist/{long-press-Dsul69gk.mjs → long-press-yJk5zK0j.mjs}

@@ -1,7 +1,7 @@
-import { n as disableTextSelection, t as createPressEvent } from "./press-event-Cd2OPpmw.mjs";
-import { t as createPress } from "./press-N_mE3Mgx.mjs";
+import { n as disableTextSelection, t as createPressEvent } from "./press-event-xlWYF9py.mjs";
+import { t as createPress } from "./press-BjLm6bKg.mjs";
 import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
-//#region src/long-press-internal.ts
+//#region src/families/interaction/long-press/long-press-internal.ts
 const defaultThreshold = 500;
 const invalidOptionDiagnostic = "VIZE_UI_LONG_PRESS_OPTION";
 const hardwarePointers = new Set([
@@ -139,7 +139,7 @@ function installTriggeredRelease(current, finish) {
 	};
 }
 //#endregion
-//#region src/long-press.ts
+//#region src/families/interaction/long-press/long-press.ts
 const contextMenuLingerMs = 50;
 const disposedDiagnostic = "VIZE_UI_LONG_PRESS_DISPOSED";
 const setupDiagnostic = "VIZE_UI_LONG_PRESS_SETUP";

package/dist/long-press.d.mts

@@ -1,2 +1,2 @@
-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-cll6z2K9.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-DyYxp191.mjs";
 export { type LongPressController, type LongPressEvent, type LongPressEventType, type LongPressOptions, type LongPressPointerType, type LongPressProps, createLongPress, useLongPress };

package/dist/long-press.mjs

@@ -1,2 +1,2 @@
-import { n as useLongPress, t as createLongPress } from "./long-press-Dsul69gk.mjs";
+import { n as useLongPress, t as createLongPress } from "./long-press-yJk5zK0j.mjs";
 export { createLongPress, useLongPress };

package/dist/measure-4I0YOAXD.d.mts

@@ -0,0 +1,97 @@
+import { ShallowRef } from "vue";
+
+//#region src/families/interaction/measure/measure-types.d.ts
+/** One measured border-box change reported by a size observer. */
+interface SizeObserverEntry {
+  /** Observed element that changed size. */
+  readonly target: Element;
+  /** Inline-axis extent in CSS pixels for the configured box. */
+  readonly width: number;
+  /** Block-axis extent in CSS pixels for the configured box. */
+  readonly height: number;
+}
+/** Options shared by {@link createSizeObserver} and {@link useSizeObserver}. */
+interface SizeObserverOptions {
+  /**
+   * Box model reported for every observed target.
+   *
+   * @default "border-box"
+   */
+  readonly box?: "border-box" | "content-box";
+  /** Called with each batch of size changes, in observation order. */
+  readonly onResize: (entries: readonly SizeObserverEntry[]) => void;
+}
+/** SSR-safe `ResizeObserver` wrapper for a stable set of targets. */
+interface SizeObserverController {
+  /** Whether the platform provides `ResizeObserver`. Always `false` during SSR. */
+  readonly isSupported: boolean;
+  /** Number of currently observed targets. */
+  readonly observedCount: Readonly<ShallowRef<number>>;
+  /** Start observing one element. Repeated calls for one element are idempotent. */
+  readonly observe: (target: Element) => void;
+  /** Stop observing one element. Unknown elements are ignored. */
+  readonly unobserve: (target: Element) => void;
+  /** Stop observing every element while keeping the controller usable. */
+  readonly disconnect: () => void;
+  /** Disconnect and freeze the controller. Further observation throws. */
+  readonly dispose: () => void;
+}
+/** One visibility change reported by a visibility observer. */
+interface VisibilityObserverEntry {
+  /** Observed element whose intersection changed. */
+  readonly target: Element;
+  /** Whether the target intersects the observation root. */
+  readonly isIntersecting: boolean;
+  /** Fraction of the target inside the root, from `0` to `1`. */
+  readonly intersectionRatio: number;
+}
+/** Options shared by {@link createVisibilityObserver} and {@link useVisibilityObserver}. */
+interface VisibilityObserverOptions {
+  /**
+   * Intersection root. `null` observes against the viewport.
+   *
+   * @default null
+   */
+  readonly root?: Element | Document | null;
+  /**
+   * Margin applied to the root bounding box before intersection.
+   *
+   * @default "0px"
+   */
+  readonly rootMargin?: string;
+  /**
+   * Intersection ratios at which changes are reported.
+   *
+   * @default 0
+   */
+  readonly threshold?: number | readonly number[];
+  /** Called with each batch of visibility changes, in observation order. */
+  readonly onVisibilityChange: (entries: readonly VisibilityObserverEntry[]) => void;
+}
+/** SSR-safe `IntersectionObserver` wrapper for a stable set of targets. */
+interface VisibilityObserverController {
+  /** Whether the platform provides `IntersectionObserver`. Always `false` during SSR. */
+  readonly isSupported: boolean;
+  /** Number of currently observed targets. */
+  readonly observedCount: Readonly<ShallowRef<number>>;
+  /** Start observing one element. Repeated calls for one element are idempotent. */
+  readonly observe: (target: Element) => void;
+  /** Stop observing one element. Unknown elements are ignored. */
+  readonly unobserve: (target: Element) => void;
+  /** Stop observing every element while keeping the controller usable. */
+  readonly disconnect: () => void;
+  /** Disconnect and freeze the controller. Further observation throws. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/families/interaction/measure/measure-runtime.d.ts
+/** Create an SSR-safe `ResizeObserver` wrapper. Observation no-ops without platform support. */
+declare function createSizeObserver(options: SizeObserverOptions): SizeObserverController;
+/** Create an SSR-safe `IntersectionObserver` wrapper. Observation no-ops without support. */
+declare function createVisibilityObserver(options: VisibilityObserverOptions): VisibilityObserverController;
+/** Create a size observer disposed with the current Vue effect scope. */
+declare function useSizeObserver(options: SizeObserverOptions): SizeObserverController;
+/** Create a visibility observer disposed with the current Vue effect scope. */
+declare function useVisibilityObserver(options: VisibilityObserverOptions): VisibilityObserverController;
+//#endregion
+export { SizeObserverController as a, VisibilityObserverController as c, useVisibilityObserver as i, VisibilityObserverEntry as l, createVisibilityObserver as n, SizeObserverEntry as o, useSizeObserver as r, SizeObserverOptions as s, createSizeObserver as t, VisibilityObserverOptions as u };

package/dist/measure-runtime-C4qYJp3_.mjs

@@ -0,0 +1,170 @@
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef } from "vue";
+//#region src/families/interaction/measure/measure-runtime.ts
+const invalidOptionDiagnostic = "VIZE_UI_MEASURE_OPTION";
+const disposedDiagnostic = "VIZE_UI_MEASURE_DISPOSED";
+const setupDiagnostic = "VIZE_UI_MEASURE_SETUP";
+const boxes = new Set(["border-box", "content-box"]);
+function assertCallback(name, value) {
+	if (typeof value !== "function") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must be a function`);
+}
+function assertElement(target) {
+	if (!target || target.nodeType !== 1) throw new TypeError(`${invalidOptionDiagnostic}: observation targets must be elements`);
+}
+function readBoxSize(entry, box) {
+	const boxSize = box === "border-box" ? entry.borderBoxSize : entry.contentBoxSize;
+	const size = Array.isArray(boxSize) ? boxSize[0] : void 0;
+	if (size && typeof size.inlineSize === "number" && typeof size.blockSize === "number") return {
+		width: size.inlineSize,
+		height: size.blockSize
+	};
+	return {
+		width: entry.contentRect.width,
+		height: entry.contentRect.height
+	};
+}
+/** Shared observe/unobserve/disconnect/dispose lifecycle for both wrappers. */
+function createObservationLifecycle(adapter) {
+	const observed = /* @__PURE__ */ new Set();
+	const observedCount = shallowRef(0);
+	let disposed = false;
+	const assertUsable = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const disconnect = () => {
+		assertUsable();
+		for (const target of observed) adapter.unobserve(target);
+		observed.clear();
+		observedCount.value = 0;
+	};
+	return {
+		isSupported: adapter.isSupported,
+		observedCount: shallowReadonly(observedCount),
+		isObserved: (target) => observed.has(target),
+		translate: (entries) => adapter.translate(entries),
+		observe: (target) => {
+			assertUsable();
+			assertElement(target);
+			if (!adapter.isSupported || observed.has(target)) return;
+			adapter.observe(target);
+			observed.add(target);
+			observedCount.value = observed.size;
+		},
+		unobserve: (target) => {
+			assertUsable();
+			if (!observed.delete(target)) return;
+			adapter.unobserve(target);
+			observedCount.value = observed.size;
+		},
+		disconnect,
+		dispose: () => {
+			if (disposed) return;
+			disconnect();
+			disposed = true;
+			adapter.release();
+		}
+	};
+}
+/** Create an SSR-safe `ResizeObserver` wrapper. Observation no-ops without platform support. */
+function createSizeObserver(options) {
+	assertCallback("onResize", options.onResize);
+	const box = options.box ?? "border-box";
+	if (!boxes.has(box)) throw new TypeError(`${invalidOptionDiagnostic}: box must be border-box or content-box`);
+	const Observer = typeof globalThis.ResizeObserver === "function" ? ResizeObserver : null;
+	const isSupported = Observer !== null;
+	let observer = null;
+	const lifecycle = createObservationLifecycle({
+		isSupported,
+		observe(target) {
+			if (!Observer) return;
+			observer ??= new Observer((entries) => lifecycle.translate(entries));
+			observer.observe(target, { box });
+		},
+		unobserve(target) {
+			observer?.unobserve(target);
+		},
+		translate(entries) {
+			const changes = [];
+			for (const entry of entries) {
+				if (!lifecycle.isObserved(entry.target)) continue;
+				changes.push(Object.freeze({
+					target: entry.target,
+					...readBoxSize(entry, box)
+				}));
+			}
+			if (changes.length > 0) options.onResize(Object.freeze(changes));
+		},
+		release() {
+			observer?.disconnect();
+			observer = null;
+		}
+	});
+	return Object.freeze({
+		isSupported,
+		observedCount: lifecycle.observedCount,
+		observe: lifecycle.observe,
+		unobserve: lifecycle.unobserve,
+		disconnect: lifecycle.disconnect,
+		dispose: lifecycle.dispose
+	});
+}
+/** Create an SSR-safe `IntersectionObserver` wrapper. Observation no-ops without support. */
+function createVisibilityObserver(options) {
+	assertCallback("onVisibilityChange", options.onVisibilityChange);
+	const Observer = typeof globalThis.IntersectionObserver === "function" ? IntersectionObserver : null;
+	const isSupported = Observer !== null;
+	let observer = null;
+	const lifecycle = createObservationLifecycle({
+		isSupported,
+		observe(target) {
+			if (!Observer) return;
+			observer ??= new Observer((entries) => lifecycle.translate(entries), {
+				root: options.root ?? null,
+				rootMargin: options.rootMargin ?? "0px",
+				threshold: options.threshold ?? 0
+			});
+			observer.observe(target);
+		},
+		unobserve(target) {
+			observer?.unobserve(target);
+		},
+		translate(entries) {
+			const changes = [];
+			for (const entry of entries) {
+				if (!lifecycle.isObserved(entry.target)) continue;
+				changes.push(Object.freeze({
+					target: entry.target,
+					isIntersecting: entry.isIntersecting,
+					intersectionRatio: entry.intersectionRatio
+				}));
+			}
+			if (changes.length > 0) options.onVisibilityChange(Object.freeze(changes));
+		},
+		release() {
+			observer?.disconnect();
+			observer = null;
+		}
+	});
+	return Object.freeze({
+		isSupported,
+		observedCount: lifecycle.observedCount,
+		observe: lifecycle.observe,
+		unobserve: lifecycle.unobserve,
+		disconnect: lifecycle.disconnect,
+		dispose: lifecycle.dispose
+	});
+}
+function bindToScope(controller) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+/** Create a size observer disposed with the current Vue effect scope. */
+function useSizeObserver(options) {
+	return bindToScope(createSizeObserver(options));
+}
+/** Create a visibility observer disposed with the current Vue effect scope. */
+function useVisibilityObserver(options) {
+	return bindToScope(createVisibilityObserver(options));
+}
+//#endregion
+export { useVisibilityObserver as i, createVisibilityObserver as n, useSizeObserver as r, createSizeObserver as t };

package/dist/measure.d.mts

@@ -0,0 +1,2 @@
+import { a as SizeObserverController, c as VisibilityObserverController, i as useVisibilityObserver, l as VisibilityObserverEntry, n as createVisibilityObserver, o as SizeObserverEntry, r as useSizeObserver, s as SizeObserverOptions, t as createSizeObserver, u as VisibilityObserverOptions } from "./measure-4I0YOAXD.mjs";
+export { type SizeObserverController, type SizeObserverEntry, type SizeObserverOptions, type VisibilityObserverController, type VisibilityObserverEntry, type VisibilityObserverOptions, createSizeObserver, createVisibilityObserver, useSizeObserver, useVisibilityObserver };

package/dist/measure.mjs

@@ -0,0 +1,2 @@
+import { i as useVisibilityObserver, n as createVisibilityObserver, r as useSizeObserver, t as createSizeObserver } from "./measure-runtime-C4qYJp3_.mjs";
+export { createSizeObserver, createVisibilityObserver, useSizeObserver, useVisibilityObserver };

package/dist/media-pdf.d.mts

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

package/dist/media-pdf.mjs

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

package/dist/media-source.d.mts

@@ -1,4 +1,4 @@
-//#region src/media-source.d.ts
+//#region src/media/media-source.d.ts
 /** Media resource category used to constrain inline data. */
 type MediaSourceKind = "audio" | "image" | "pdf" | "stream" | "track" | "video";
 /** Options for {@link normalizeMediaSource}. */

package/dist/media-source.mjs

@@ -1,4 +1,4 @@
-//#region src/media-source.ts
+//#region src/media/media-source.ts
 const SOURCE_KINDS = new Set([
 	"audio",
 	"image",

package/dist/media.d.mts

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

package/dist/media.mjs

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