@vizejs/ui 0.345.0 → 0.350.2

package/dist/interaction-modality-jgHKjPFB.d.mts

@@ -0,0 +1,89 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/interaction-modality-types.d.ts
+/**
+ * Input family that most recently expressed user intent.
+ *
+ * Pens and unknown pointing hardware intentionally map to `pointer`; consumers
+ * that need device-specific geometry should inspect the original pointer event.
+ */
+type InteractionModality = "keyboard" | "pointer" | "touch" | "virtual";
+/** Why an {@link InteractionModalityTracker} changed. */
+type InteractionModalityChangeReason = InteractionModality | "document" | "manual";
+/** Immutable notification emitted after a distinct modality change. */
+interface InteractionModalityChange {
+  /** New modality, or `null` when a consumer explicitly resets detection. */
+  readonly modality: InteractionModality | null;
+  /** Value observed immediately before this change. */
+  readonly previousModality: InteractionModality | null;
+  /** Event classification or lifecycle operation responsible for the change. */
+  readonly reason: InteractionModalityChangeReason;
+  /** Native event when the change came from document input. */
+  readonly originalEvent: Event | null;
+  /** Document whose state produced the change, if the tracker is attached. */
+  readonly document: Document | null;
+}
+/** Options for {@link createInteractionModalityTracker}. */
+interface InteractionModalityOptions {
+  /**
+   * Reactive document to observe. Pass `null` for SSR or deferred attachment.
+   *
+   * When omitted, the current global document is resolved lazily. No DOM global
+   * is read while the module is evaluated.
+   *
+   * @default globalThis.document when available
+   */
+  readonly document?: MaybeRefOrGetter<Document | null | undefined>;
+  /**
+   * Value used before the first qualifying input event.
+   *
+   * @default null
+   */
+  readonly initialModality?: InteractionModality | null;
+  /** Called synchronously after each distinct change. */
+  readonly onChange?: (change: InteractionModalityChange) => void;
+}
+/** Reactive, explicitly disposable input-modality observer. */
+interface InteractionModalityTracker {
+  /** Document currently observed by this tracker. */
+  readonly document: Readonly<ShallowRef<Document | null>>;
+  /** Most recently detected input family. */
+  readonly modality: Readonly<ShallowRef<InteractionModality | null>>;
+  /** Whether global focus treatment should currently be keyboard-visible. */
+  readonly isFocusVisible: ComputedRef<boolean>;
+  /** Attach to another document, retaining the current value until synchronized. */
+  readonly attach: (document: Document | null) => boolean;
+  /** Stop observing the current document without clearing the current value. */
+  readonly detach: () => boolean;
+  /** Explicitly set or reset modality and synchronize peers on the same document. */
+  readonly setModality: (modality: InteractionModality | null) => boolean;
+  /** Release reactive observation and native listeners. Safe to call repeatedly. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/interaction-modality.d.ts
+/**
+ * Create an SSR-safe, document-scoped interaction-modality observer.
+ *
+ * Trackers in one document share native capture listeners and state. Separate
+ * documents, including iframes, remain isolated. Call {@link InteractionModalityTracker.dispose}
+ * when using this factory outside a Vue effect scope.
+ */
+declare function createInteractionModalityTracker(options?: InteractionModalityOptions): InteractionModalityTracker;
+/**
+ * Create a tracker owned by the current Vue effect scope.
+ *
+ * The tracker is disposed automatically when its component or effect scope is
+ * destroyed, preventing document-listener leaks.
+ */
+declare function useInteractionModality(options?: InteractionModalityOptions): InteractionModalityTracker;
+/**
+ * Determine whether a focused element should expose its focus indicator.
+ *
+ * Native `:focus-visible` semantics take precedence. The modality fallback is
+ * used only when the selector is unsupported, preserving text-input and
+ * platform heuristics implemented by the browser.
+ */
+declare function isElementFocusVisible(element: Element | null | undefined, modality: InteractionModality | null): boolean;
+//#endregion
+export { InteractionModalityChange as a, InteractionModalityTracker as c, InteractionModality as i, isElementFocusVisible as n, InteractionModalityChangeReason as o, useInteractionModality as r, InteractionModalityOptions as s, createInteractionModalityTracker as t };

package/dist/interaction-modality.d.mts

@@ -0,0 +1,2 @@
+import { a as InteractionModalityChange, c as InteractionModalityTracker, i as InteractionModality, n as isElementFocusVisible, o as InteractionModalityChangeReason, r as useInteractionModality, s as InteractionModalityOptions, t as createInteractionModalityTracker } from "./interaction-modality-jgHKjPFB.mjs";
+export { type InteractionModality, type InteractionModalityChange, type InteractionModalityChangeReason, type InteractionModalityOptions, type InteractionModalityTracker, createInteractionModalityTracker, isElementFocusVisible, useInteractionModality };

package/dist/interaction-modality.mjs

@@ -0,0 +1,2 @@
+import { n as isElementFocusVisible, r as useInteractionModality, t as createInteractionModalityTracker } from "./interaction-modality-DOZK0BpZ.mjs";
+export { createInteractionModalityTracker, isElementFocusVisible, useInteractionModality };

package/dist/long-press-Dsul69gk.mjs

@@ -0,0 +1,340 @@
+import { n as disableTextSelection, t as createPressEvent } from "./press-event-Cd2OPpmw.mjs";
+import { t as createPress } from "./press-N_mE3Mgx.mjs";
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
+//#region src/long-press-internal.ts
+const defaultThreshold = 500;
+const invalidOptionDiagnostic = "VIZE_UI_LONG_PRESS_OPTION";
+const hardwarePointers = new Set([
+	"mouse",
+	"pen",
+	"pointer",
+	"touch"
+]);
+function isHardwarePointer(value) {
+	return hardwarePointers.has(value);
+}
+function ownerOf(event) {
+	const original = event.originalEvent;
+	if (original && "pointerId" in original) return {
+		id: Number(original.pointerId),
+		source: "pointer"
+	};
+	if (original && "changedTouches" in original) {
+		const id = original.changedTouches.item(0)?.identifier;
+		if (id !== void 0) return {
+			id,
+			source: "touch"
+		};
+	}
+	return { source: "mouse" };
+}
+function ownerMatches(owner, event) {
+	const original = event.originalEvent;
+	if (owner.source === "pointer") return Boolean(original && "pointerId" in original && Number(original.pointerId) === owner.id);
+	if (owner.source === "touch") return Boolean(original && "changedTouches" in original && Array.from(original.changedTouches).some(({ identifier }) => identifier === owner.id));
+	return Boolean(original && !("pointerId" in original) && !("changedTouches" in original));
+}
+function captureError(errors, callback) {
+	try {
+		callback();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function surfaceErrors(errors, message) {
+	if (errors.length === 1) throw errors[0];
+	if (errors.length < 2) return;
+	const Aggregate = globalThis.AggregateError;
+	if (typeof Aggregate === "function") throw new Aggregate(errors, message);
+	const fallback = Object.assign(new Error(message), { errors: [...errors] });
+	fallback.name = "AggregateError";
+	throw fallback;
+}
+function readBoolean(value, name) {
+	const resolved = toValue(value);
+	if (resolved === void 0) return false;
+	if (typeof resolved !== "boolean") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must resolve to a boolean`);
+	return resolved;
+}
+function readPointerType(value) {
+	const resolved = toValue(value) ?? null;
+	if (resolved !== null && !hardwarePointers.has(resolved)) throw new TypeError(`${invalidOptionDiagnostic}: pointerType must resolve to mouse, pen, pointer, or touch`);
+	return resolved;
+}
+function readThreshold(value) {
+	const resolved = toValue(value) ?? defaultThreshold;
+	if (typeof resolved !== "number" || !Number.isFinite(resolved) || resolved < 0) throw new TypeError(`${invalidOptionDiagnostic}: threshold must resolve to a finite number >= 0`);
+	return resolved;
+}
+function readText(value, name) {
+	const resolved = toValue(value);
+	if (resolved === void 0 || resolved === "") return void 0;
+	if (typeof resolved !== "string") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must resolve to a string`);
+	return resolved;
+}
+function toLongPressEvent(type, event, originalEvent = event.originalEvent, isCanceled = event.isCanceled, touchIdentifier = null) {
+	const snapshot = createPressEvent("pressend", event.target, event.pointerType, originalEvent, isCanceled, touchIdentifier);
+	return Object.freeze({
+		...snapshot,
+		type
+	});
+}
+function validateOptions(options) {
+	for (const name of [
+		"onLongPress",
+		"onLongPressEnd",
+		"onLongPressStart",
+		"onPress"
+	]) {
+		const callback = options[name];
+		if (callback !== void 0 && typeof callback !== "function") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must be a function`);
+	}
+	if (typeof options.threshold !== "function") readThreshold(options.threshold);
+	if (typeof options.pointerType !== "function") readPointerType(options.pointerType);
+}
+/** Install physical-release listeners for an already triggered attempt. */
+function installTriggeredRelease(current, finish) {
+	const removals = [];
+	const document = current.target.ownerDocument;
+	const listen = (owner, type, callback, capture = true) => {
+		owner.addEventListener(type, callback, capture);
+		removals.push(() => owner.removeEventListener(type, callback, capture));
+	};
+	try {
+		if (current.owner.source === "pointer") {
+			const id = current.owner.id;
+			listen(document, "pointerup", ((event) => {
+				if (event.pointerId === id) finish(event);
+			}));
+			listen(document, "pointercancel", ((event) => {
+				if (event.pointerId === id) finish(event, true);
+			}));
+		} else if (current.owner.source === "touch") {
+			const id = current.owner.id;
+			const ownsTouch = (event) => Array.from(event.changedTouches).some((touch) => touch.identifier === id);
+			listen(document, "touchend", ((event) => {
+				if (ownsTouch(event)) finish(event);
+			}));
+			listen(document, "touchcancel", ((event) => {
+				if (ownsTouch(event)) finish(event, true);
+			}));
+		} else listen(document, "mouseup", ((event) => {
+			if (event.button === 0) finish(event);
+		}));
+		listen(document, "dragstart", (event) => finish(event, true));
+		listen(document, "visibilitychange", (() => {
+			if (document.visibilityState === "hidden") finish(null, true);
+		}));
+		if (document.defaultView) listen(document.defaultView, "blur", (event) => finish(event, true), false);
+	} catch (error) {
+		const errors = [error];
+		for (const remove of removals.reverse()) captureError(errors, remove);
+		surfaceErrors(errors, "Long-press listener setup failed");
+		throw error;
+	}
+	return () => {
+		const errors = [];
+		for (const remove of removals.splice(0)) captureError(errors, remove);
+		surfaceErrors(errors, "Long-press listener cleanup failed");
+	};
+}
+//#endregion
+//#region src/long-press.ts
+const contextMenuLingerMs = 50;
+const disposedDiagnostic = "VIZE_UI_LONG_PRESS_DISPOSED";
+const setupDiagnostic = "VIZE_UI_LONG_PRESS_SETUP";
+/** Create an SSR-safe long-press recognizer for one host element. */
+function createLongPress(options = {}) {
+	validateOptions(options);
+	const isPressed = shallowRef(false);
+	const isLongPressed = shallowRef(false);
+	let attempt = null;
+	let releaseTriggered = null;
+	let restoreTriggeredSelection = null;
+	let contextMenuPointer = null;
+	let contextMenuTimer = null;
+	let endingAtThreshold = false;
+	let disposed = false;
+	const clearContextMenuTimer = () => {
+		if (contextMenuTimer !== null) clearTimeout(contextMenuTimer);
+		contextMenuTimer = null;
+	};
+	const lingerContextMenuSuppression = () => {
+		clearContextMenuTimer();
+		contextMenuTimer = setTimeout(() => {
+			contextMenuPointer = null;
+			contextMenuTimer = null;
+		}, contextMenuLingerMs);
+	};
+	const clearRelease = () => {
+		const release = releaseTriggered;
+		const restore = restoreTriggeredSelection;
+		releaseTriggered = null;
+		restoreTriggeredSelection = null;
+		const errors = [];
+		try {
+			captureError(errors, () => release?.());
+		} finally {
+			captureError(errors, () => restore?.());
+		}
+		surfaceErrors(errors, "Long-press release cleanup failed");
+	};
+	const clearAttempt = (owner = attempt) => {
+		if (!owner || attempt !== owner) return false;
+		const timer = owner.timer;
+		if (timer != null) clearTimeout(timer);
+		attempt = null;
+		return true;
+	};
+	const finishTriggered = (owner, originalEvent, isCanceled) => {
+		if (!isLongPressed.value || attempt !== owner) return false;
+		const errors = [];
+		captureError(errors, clearRelease);
+		clearAttempt(owner);
+		isPressed.value = false;
+		isLongPressed.value = false;
+		captureError(errors, lingerContextMenuSuppression);
+		let canceled = isCanceled;
+		try {
+			canceled ||= readBoolean(options.isDisabled, "isDisabled");
+		} catch (error) {
+			canceled = true;
+			errors.push(error);
+		}
+		captureError(errors, () => options.onLongPressEnd?.(toLongPressEvent("longpressend", owner.event, originalEvent, canceled, owner.touchIdentifier)));
+		surfaceErrors(errors, "Long-press completion failed");
+		return true;
+	};
+	let press;
+	const trigger = (current) => {
+		if (disposed || attempt !== current) return;
+		current.timer = null;
+		if (readBoolean(options.isDisabled, "isDisabled")) {
+			press.cancel();
+			return;
+		}
+		isLongPressed.value = true;
+		try {
+			releaseTriggered = installTriggeredRelease(current, (event, canceled = false) => finishTriggered(current, event, canceled));
+		} catch (error) {
+			const errors = [error];
+			clearAttempt(current);
+			isPressed.value = false;
+			isLongPressed.value = false;
+			contextMenuPointer = null;
+			endingAtThreshold = true;
+			try {
+				captureError(errors, press.cancel);
+			} finally {
+				endingAtThreshold = false;
+			}
+			surfaceErrors(errors, "Long-press trigger setup failed");
+			return;
+		}
+		endingAtThreshold = true;
+		try {
+			press.cancel();
+		} finally {
+			endingAtThreshold = false;
+		}
+		const focusable = current.target;
+		if ((current.pointerType === "touch" || current.pointerType === "pen") && current.target.ownerDocument.activeElement !== current.target && typeof focusable.focus === "function") try {
+			focusable.focus({ preventScroll: true });
+		} catch {
+			focusable.focus();
+		}
+		if (!readBoolean(options.allowTextSelectionOnPress, "allowTextSelectionOnPress")) restoreTriggeredSelection = disableTextSelection(current.target);
+		options.onLongPress?.(toLongPressEvent("longpress", current.event, current.event.originalEvent, current.event.isCanceled, current.touchIdentifier));
+	};
+	press = createPress({
+		...options.isDisabled === void 0 ? {} : { isDisabled: options.isDisabled },
+		...options.allowTextSelectionOnPress === void 0 ? {} : { allowTextSelectionOnPress: options.allowTextSelectionOnPress },
+		...options.preventFocusOnPress === void 0 ? {} : { preventFocusOnPress: options.preventFocusOnPress },
+		shouldCancelOnPointerExit: true,
+		onPressStart(event) {
+			if (!isHardwarePointer(event.pointerType)) return;
+			const pointerType = event.pointerType;
+			const filter = readPointerType(options.pointerType);
+			if (filter && filter !== pointerType) return;
+			if (attempt) {
+				press.cancel();
+				return;
+			}
+			contextMenuPointer = pointerType;
+			clearContextMenuTimer();
+			const owner = ownerOf(event);
+			const touchIdentifier = owner.source === "touch" ? owner.id : null;
+			const start = toLongPressEvent("longpressstart", event, event.originalEvent, event.isCanceled, touchIdentifier);
+			const current = {
+				event: start,
+				owner,
+				pointerType,
+				target: event.target,
+				touchIdentifier,
+				timer: null
+			};
+			attempt = current;
+			isPressed.value = true;
+			current.timer = setTimeout(() => trigger(current), readThreshold(options.threshold));
+			options.onLongPressStart?.(start);
+		},
+		onPressEnd(event) {
+			if (!attempt || endingAtThreshold) return;
+			const current = attempt;
+			if (!ownerMatches(current.owner, event)) return;
+			clearAttempt(current);
+			isPressed.value = false;
+			if (current.pointerType === "touch" || current.pointerType === "pen") lingerContextMenuSuppression();
+			else contextMenuPointer = null;
+			options.onLongPressEnd?.(toLongPressEvent("longpressend", current.event, event.originalEvent, event.isCanceled, current.touchIdentifier));
+		},
+		...options.onPress ? { onPress: options.onPress } : {}
+	});
+	const attributes = {
+		...press.pressProps,
+		get "aria-describedby"() {
+			if (readBoolean(options.isDisabled, "isDisabled") || !options.onLongPress) return void 0;
+			return readText(options.accessibilityDescriptionId, "accessibilityDescriptionId");
+		},
+		get "aria-description"() {
+			if (readBoolean(options.isDisabled, "isDisabled") || !options.onLongPress) return void 0;
+			if (readText(options.accessibilityDescriptionId, "accessibilityDescriptionId")) return void 0;
+			return readText(options.accessibilityDescription, "accessibilityDescription");
+		},
+		onContextmenu(event) {
+			if (contextMenuPointer === "touch" || contextMenuPointer === "pen") event.preventDefault();
+		}
+	};
+	return Object.freeze({
+		isPressed: shallowReadonly(isPressed),
+		isLongPressed: shallowReadonly(isLongPressed),
+		longPressProps: Object.freeze(attributes),
+		cancel: () => {
+			if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+			if (attempt && finishTriggered(attempt, null, true)) return true;
+			return press.cancel();
+		},
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const errors = [];
+			captureError(errors, clearRelease);
+			captureError(errors, () => clearAttempt());
+			captureError(errors, clearContextMenuTimer);
+			contextMenuPointer = null;
+			isPressed.value = false;
+			isLongPressed.value = false;
+			captureError(errors, press.dispose);
+			surfaceErrors(errors, "Long-press disposal failed");
+		}
+	});
+}
+/** Create a long-press recognizer disposed with the current Vue effect scope. */
+function useLongPress(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createLongPress(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useLongPress as n, createLongPress as t };

package/dist/long-press-cll6z2K9.d.mts

@@ -0,0 +1,105 @@
+import { n as PressEvent, o as PressPointerType, s as PressProps } from "./press-types-CNqStzJf.mjs";
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/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. */
+type LongPressEventType = "longpress" | "longpressend" | "longpressstart";
+/** Immutable snapshot of one long-press lifecycle event. */
+interface LongPressEvent extends Omit<PressEvent, "type" | "pointerType"> {
+  /** Long-press lifecycle phase represented by this snapshot. */
+  readonly type: LongPressEventType;
+  /** Pointing-device family that initiated the interaction. */
+  readonly pointerType: LongPressPointerType;
+}
+/** Options shared by {@link createLongPress} and {@link useLongPress}. */
+interface LongPressOptions {
+  /**
+   * Suppress long and short activation while retaining the bound props.
+   * Reactive values are checked at start and again when the threshold elapses.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Restrict long-press recognition to one pointing-device family.
+   * Keyboard and virtual activation remain available through `onPress`.
+   *
+   * @default undefined
+   */
+  readonly pointerType?: MaybeRefOrGetter<LongPressPointerType | undefined>;
+  /**
+   * Time in milliseconds that the primary pointer must remain down.
+   * The value is resolved once per attempt and must be finite and non-negative.
+   *
+   * @default 500
+   */
+  readonly threshold?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Accessible explanation of the long action, for example
+   * "Long press to open actions". Used as `aria-description` unless
+   * `accessibilityDescriptionId` is supplied.
+   */
+  readonly accessibilityDescription?: MaybeRefOrGetter<string | undefined>;
+  /**
+   * ID of consumer-rendered descriptive content. When supplied, the host uses
+   * `aria-describedby` and the inline accessibility description is omitted.
+   */
+  readonly accessibilityDescriptionId?: MaybeRefOrGetter<string | undefined>;
+  /**
+   * Preserve selectable text during the pointer attempt.
+   *
+   * @default false
+   */
+  readonly allowTextSelectionOnPress?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Prevent the compatibility mousedown default that normally moves focus.
+   *
+   * @default false
+   */
+  readonly preventFocusOnPress?: MaybeRefOrGetter<boolean | undefined>;
+  /** Called after a qualifying primary pointer starts. */
+  readonly onLongPressStart?: (event: LongPressEvent) => void;
+  /** Called when an attempt ends, whether before or after the threshold. */
+  readonly onLongPressEnd?: (event: LongPressEvent) => void;
+  /** Called exactly once when the configured threshold is reached. */
+  readonly onLongPress?: (event: LongPressEvent) => void;
+  /**
+   * Called for an ordinary short, keyboard, or virtual activation.
+   * Use this as the keyboard-accessible alternative to a long-only action.
+   */
+  readonly onPress?: (event: PressEvent) => void;
+}
+/** Attributes and native handlers to spread onto one long-press host. */
+interface LongPressProps extends PressProps {
+  readonly "aria-describedby": string | undefined;
+  readonly "aria-description": string | undefined;
+  readonly onContextmenu: (event: MouseEvent) => void;
+}
+/** Stateful long-press recognizer with explicit lifecycle ownership. */
+interface LongPressController {
+  /** Whether an eligible pointer attempt is currently active. */
+  readonly isPressed: Readonly<ShallowRef<boolean>>;
+  /** Whether the active attempt has crossed the configured threshold. */
+  readonly isLongPressed: Readonly<ShallowRef<boolean>>;
+  /** Stable handlers and accessibility attributes for exactly one host. */
+  readonly longPressProps: Readonly<LongPressProps>;
+  /**
+   * Cancel the current pending or triggered interaction.
+   * Returns `true` when an interaction was canceled.
+   *
+   * @throws Error with `VIZE_UI_LONG_PRESS_DISPOSED` after disposal.
+   */
+  readonly cancel: () => boolean;
+  /** Release timers, listeners, selection guards, and reactive state. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/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. */
+declare function useLongPress(options?: LongPressOptions): LongPressController;
+//#endregion
+export { LongPressEventType as a, LongPressProps as c, LongPressEvent as i, useLongPress as n, LongPressOptions as o, LongPressController as r, LongPressPointerType as s, createLongPress as t };

package/dist/long-press.d.mts

@@ -0,0 +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";
+export { type LongPressController, type LongPressEvent, type LongPressEventType, type LongPressOptions, type LongPressPointerType, type LongPressProps, createLongPress, useLongPress };

package/dist/long-press.mjs

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

package/dist/media-pdf.d.mts

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

package/dist/media-pdf.mjs

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

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-COxN3A1l.mjs";
+import { n as createPDFSource, t as CreatePDFSourceOptions } from "./pdf-source-BYFK2Pks.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-C52YE8tp.mjs";
+import { t as createPDFSource } from "./pdf-source-zu1LkCeE.mjs";
 export { createPDFSource, normalizeMediaSource };

package/dist/move-BOmXDYbh.d.mts

@@ -0,0 +1,103 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/move-types.d.ts
+/** Input families normalized by the move interaction. */
+type MovePointerType = "keyboard" | "mouse" | "pen" | "pointer" | "touch";
+/** Lifecycle phases emitted by a move controller. */
+type MoveEventType = "move" | "moveend" | "movestart";
+interface MoveEventBase<Type extends MoveEventType> {
+  /** Move lifecycle phase represented by this immutable snapshot. */
+  readonly type: Type;
+  /** Input family that owns this movement. */
+  readonly pointerType: MovePointerType;
+  /** Element whose bound props own the interaction. */
+  readonly target: Element;
+  /** Native event responsible for this phase, or `null` for manual cancellation. */
+  readonly originalEvent: Event | null;
+  /** Page coordinates when supplied by pointing hardware. */
+  readonly x: number | null;
+  readonly y: number | null;
+  /** Modifier-key snapshots captured from the native event. */
+  readonly altKey: boolean;
+  readonly ctrlKey: boolean;
+  readonly metaKey: boolean;
+  readonly shiftKey: boolean;
+}
+/** Snapshot emitted immediately before the first non-zero movement. */
+interface MoveStartEvent extends MoveEventBase<"movestart"> {
+  readonly deltaX: 0;
+  readonly deltaY: 0;
+  readonly isCanceled: false;
+}
+/** Snapshot of one non-zero movement since the preceding native event. */
+interface MoveUpdateEvent extends MoveEventBase<"move"> {
+  readonly deltaX: number;
+  readonly deltaY: number;
+  readonly isCanceled: false;
+}
+/** Snapshot emitted after a movement completes or is canceled. */
+interface MoveEndEvent extends MoveEventBase<"moveend"> {
+  readonly deltaX: 0;
+  readonly deltaY: 0;
+  readonly isCanceled: boolean;
+}
+/** Discriminated lifecycle event union for exhaustive consumer handling. */
+type MoveEvent = MoveEndEvent | MoveStartEvent | MoveUpdateEvent;
+/** Options shared by {@link createMove} and {@link useMove}. */
+interface MoveOptions {
+  /**
+   * Suppress new movement and cancel an active pointer movement on its next event.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Distance contributed by each physical arrow-key press, including repeat events.
+   * The resolved value must be finite and greater than zero.
+   *
+   * @default 1
+   */
+  readonly keyboardStep?: MaybeRefOrGetter<number | undefined>;
+  /** Called exactly once before the first non-zero delta in an interaction. */
+  readonly onMoveStart?: (event: MoveStartEvent) => void;
+  /** Called for every non-zero pointer or keyboard delta. */
+  readonly onMove?: (event: MoveUpdateEvent) => void;
+  /** Called after an interaction that emitted at least one move finishes. */
+  readonly onMoveEnd?: (event: MoveEndEvent) => void;
+}
+/** Native handlers to spread onto exactly one move host. */
+interface MoveProps {
+  readonly onDragstart: (event: DragEvent) => void;
+  readonly onKeydown: (event: KeyboardEvent) => void;
+  readonly onMousedown: (event: MouseEvent) => void;
+  readonly onPointercancel: (event: PointerEvent) => void;
+  readonly onPointerdown: (event: PointerEvent) => void;
+  readonly onTouchcancel: (event: TouchEvent) => void;
+  readonly onTouchend: (event: TouchEvent) => void;
+  readonly onTouchmove: (event: TouchEvent) => void;
+  readonly onTouchstart: (event: TouchEvent) => void;
+}
+/** Stateful move normalizer with explicit listener and selection ownership. */
+interface MoveController {
+  /** Whether a pointer or ephemeral keyboard movement is currently being emitted. */
+  readonly isMoving: Readonly<ShallowRef<boolean>>;
+  /** Stable native handlers to spread or merge onto one host. */
+  readonly moveProps: Readonly<MoveProps>;
+  /**
+   * Cancel the current pointer attempt, including one that has not moved yet.
+   *
+   * @returns `true` when an owned pointer or keyboard transaction was settled.
+   * @throws An error carrying `VIZE_UI_MOVE_DISPOSED` after disposal.
+   */
+  readonly cancel: () => boolean;
+  /** Release listeners, selection guards, and reactive state without callbacks. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/move.d.ts
+/** Create an SSR-safe mouse, pen, touch, and keyboard move normalizer. */
+declare function createMove(options?: MoveOptions): MoveController;
+/** Create a move normalizer disposed with the current Vue effect scope. */
+declare function useMove(options?: MoveOptions): MoveController;
+//#endregion
+export { MoveEvent as a, MovePointerType as c, MoveUpdateEvent as d, MoveEndEvent as i, MoveProps as l, useMove as n, MoveEventType as o, MoveController as r, MoveOptions as s, createMove as t, MoveStartEvent as u };