@vizejs/ui 0.347.7 → 0.351.0

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 };

package/dist/move-BVvMHzxr.mjs

@@ -0,0 +1,386 @@
+import { a as isPrimaryPointer, n as disableTextSelection, r as eventElement } from "./press-event-Cd2OPpmw.mjs";
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
+//#region src/move-internal.ts
+const invalidOptionDiagnostic = "VIZE_UI_MOVE_OPTION";
+function readBoolean(value) {
+	const resolved = toValue(value);
+	if (resolved === void 0) return false;
+	if (typeof resolved !== "boolean") throw new TypeError(`${invalidOptionDiagnostic}: isDisabled must resolve to a boolean`);
+	return resolved;
+}
+function readKeyboardStep(value) {
+	const resolved = toValue(value) ?? 1;
+	if (typeof resolved !== "number" || !Number.isFinite(resolved) || resolved <= 0) throw new TypeError(`${invalidOptionDiagnostic}: keyboardStep must resolve to a finite number > 0`);
+	return resolved;
+}
+function modifier(event, key) {
+	return event && key in event ? Boolean(event[key]) : false;
+}
+function positionOf(event, touchId = null) {
+	if ("pageX" in event && "pageY" in event) {
+		const x = Number(event.pageX);
+		const y = Number(event.pageY);
+		if (Number.isFinite(x) && Number.isFinite(y)) return {
+			x,
+			y
+		};
+	}
+	if ("clientX" in event && "clientY" in event) {
+		const x = Number(event.clientX);
+		const y = Number(event.clientY);
+		if (Number.isFinite(x) && Number.isFinite(y)) return {
+			x,
+			y
+		};
+	}
+	if ("changedTouches" in event) {
+		const touch = Array.from(event.changedTouches).find(({ identifier }) => touchId === null || identifier === touchId);
+		if (touch) return {
+			x: touch.pageX,
+			y: touch.pageY
+		};
+	}
+	return null;
+}
+function pointerTypeOf(event) {
+	if (event.pointerType === "mouse" || event.pointerType === "pen") return event.pointerType;
+	if (event.pointerType === "touch") return "touch";
+	return "pointer";
+}
+function createMoveEvent(type, target, pointerType, originalEvent, deltaX = 0, deltaY = 0, isCanceled = false, touchId = null) {
+	const position = originalEvent ? positionOf(originalEvent, touchId) : null;
+	return Object.freeze({
+		type,
+		pointerType,
+		target,
+		originalEvent,
+		x: position?.x ?? null,
+		y: position?.y ?? null,
+		deltaX,
+		deltaY,
+		altKey: modifier(originalEvent, "altKey"),
+		ctrlKey: modifier(originalEvent, "ctrlKey"),
+		metaKey: modifier(originalEvent, "metaKey"),
+		shiftKey: modifier(originalEvent, "shiftKey"),
+		isCanceled
+	});
+}
+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 capture(errors, callback) {
+	try {
+		callback();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function validateOptions(options) {
+	for (const name of [
+		"onMove",
+		"onMoveEnd",
+		"onMoveStart"
+	]) {
+		const callback = options[name];
+		if (callback !== void 0 && typeof callback !== "function") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must be a function`);
+	}
+	if (typeof options.keyboardStep !== "function") readKeyboardStep(options.keyboardStep);
+}
+/** Install and exhaustively clean up the document listeners for one pointer family. */
+function installMoveListeners(document, source, context) {
+	const removals = [];
+	const listen = (owner, type, callback, capture = true) => {
+		owner.addEventListener(type, callback, capture);
+		removals.push(() => owner.removeEventListener(type, callback, capture));
+	};
+	const matches = (family, id) => {
+		const current = context.getActive();
+		return current?.source === family && current.id === id ? current : null;
+	};
+	const pointerMove = (event) => {
+		const current = matches("pointer", event.pointerId);
+		const position = positionOf(event);
+		if (current && position) context.emitDelta(current, event, position);
+	};
+	const pointerEnd = (event, canceled) => {
+		const current = matches("pointer", event.pointerId);
+		if (!current) return;
+		const disabled = context.readDisabled(event);
+		context.finish(event, canceled || disabled || !current.target.isConnected);
+	};
+	const mouseMove = (event) => {
+		const current = matches("mouse", null);
+		const position = positionOf(event);
+		if (current && position) context.emitDelta(current, event, position);
+	};
+	const mouseUp = (event) => {
+		const current = matches("mouse", null);
+		if (event.button === 0 && current) context.finish(event, context.readDisabled(event) || !current.target.isConnected);
+	};
+	const touchMove = (event) => {
+		const candidate = context.getActive();
+		const current = candidate?.source === "touch" ? candidate : null;
+		const position = current ? positionOf(event, current.id) : null;
+		if (current && position) context.emitDelta(current, event, position);
+	};
+	const touchEnd = (event, canceled) => {
+		const candidate = context.getActive();
+		const current = candidate?.source === "touch" ? candidate : null;
+		if (!current || !positionOf(event, current.id)) return;
+		context.rememberTouch(event.timeStamp);
+		context.finish(event, canceled || context.readDisabled(event) || !current.target.isConnected);
+	};
+	try {
+		if (source === "pointer") {
+			listen(document, "pointermove", pointerMove);
+			listen(document, "pointerup", ((event) => pointerEnd(event, false)));
+			listen(document, "pointercancel", ((event) => pointerEnd(event, true)));
+		} else if (source === "mouse") {
+			listen(document, "mousemove", mouseMove);
+			listen(document, "mouseup", mouseUp);
+		} else {
+			listen(document, "touchmove", touchMove);
+			listen(document, "touchend", ((event) => touchEnd(event, false)));
+			listen(document, "touchcancel", ((event) => touchEnd(event, true)));
+		}
+		listen(document, "dragstart", (event) => context.finish(event, true));
+		listen(document, "visibilitychange", (() => {
+			if (document.visibilityState === "hidden") context.finish(null, true);
+		}));
+		if (document.defaultView) listen(document.defaultView, "blur", (event) => context.finish(event, true), false);
+	} catch (error) {
+		const errors = [error];
+		for (const remove of removals.reverse()) capture(errors, remove);
+		surfaceErrors(errors, "Move listener setup failed");
+		throw error;
+	}
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		const errors = [];
+		for (const remove of removals) capture(errors, remove);
+		surfaceErrors(errors, "Move listener cleanup failed");
+	};
+}
+//#endregion
+//#region src/move.ts
+const disposedDiagnostic = "VIZE_UI_MOVE_DISPOSED";
+const setupDiagnostic = "VIZE_UI_MOVE_SETUP";
+/** Create an SSR-safe mouse, pen, touch, and keyboard move normalizer. */
+function createMove(options = {}) {
+	validateOptions(options);
+	const moving = shallowRef(false);
+	let active = null;
+	let keyboard = null;
+	let disposed = false;
+	let lastTouchTime = Number.NEGATIVE_INFINITY;
+	const finish = (originalEvent, isCanceled) => {
+		const current = active;
+		if (!current) return false;
+		active = null;
+		moving.value = false;
+		const errors = [];
+		capture(errors, current.releaseListeners);
+		capture(errors, current.restoreSelection);
+		if (current.didMove) capture(errors, () => options.onMoveEnd?.(createMoveEvent("moveend", current.target, current.pointerType, originalEvent, 0, 0, isCanceled, current.source === "touch" ? current.id : null)));
+		surfaceErrors(errors, "Move completion failed");
+		return true;
+	};
+	const readDisabledDuringActive = (event) => {
+		try {
+			return readBoolean(options.isDisabled);
+		} catch (error) {
+			const errors = [error];
+			capture(errors, () => finish(event, true));
+			surfaceErrors(errors, "Move option validation failed during teardown");
+			throw error;
+		}
+	};
+	const finishKeyboard = (originalEvent, isCanceled) => {
+		const current = keyboard;
+		if (!current) return false;
+		keyboard = null;
+		moving.value = false;
+		options.onMoveEnd?.(createMoveEvent("moveend", current.target, "keyboard", originalEvent, 0, 0, isCanceled));
+		return true;
+	};
+	const emitDelta = (current, event, position) => {
+		if (active !== current) return;
+		current.lastEvent = event;
+		if (readDisabledDuringActive(event) || !current.target.isConnected) {
+			finish(event, true);
+			return;
+		}
+		const deltaX = position.x - current.position.x;
+		const deltaY = position.y - current.position.y;
+		current.position = position;
+		if (deltaX === 0 && deltaY === 0) return;
+		event.preventDefault();
+		const errors = [];
+		if (!current.didMove) {
+			current.didMove = true;
+			moving.value = true;
+			capture(errors, () => options.onMoveStart?.(createMoveEvent("movestart", current.target, current.pointerType, event, 0, 0, false, current.source === "touch" ? current.id : null)));
+		}
+		if (active === current && !disposed) capture(errors, () => options.onMove?.(createMoveEvent("move", current.target, current.pointerType, event, deltaX, deltaY, false, current.source === "touch" ? current.id : null)));
+		surfaceErrors(errors, "Move callbacks failed");
+	};
+	const matches = (source, id) => {
+		const current = active;
+		return current?.source === source && current.id === id ? current : null;
+	};
+	const start = (event, source, pointerType, id, position) => {
+		if (disposed || active || readBoolean(options.isDisabled)) return;
+		const target = eventElement(event);
+		if (!target) return;
+		event.preventDefault();
+		event.stopPropagation();
+		let releaseListeners = () => void 0;
+		let restoreSelection = () => void 0;
+		try {
+			releaseListeners = installMoveListeners(target.ownerDocument, source, {
+				emitDelta,
+				finish,
+				getActive: () => active,
+				readDisabled: readDisabledDuringActive,
+				rememberTouch: (timeStamp) => {
+					lastTouchTime = timeStamp;
+				}
+			});
+			restoreSelection = disableTextSelection(target);
+		} catch (error) {
+			const errors = [error];
+			capture(errors, releaseListeners);
+			capture(errors, restoreSelection);
+			surfaceErrors(errors, "Move start cleanup failed");
+			throw error;
+		}
+		active = {
+			id,
+			pointerType,
+			releaseListeners,
+			restoreSelection,
+			source,
+			target,
+			didMove: false,
+			lastEvent: event,
+			position
+		};
+	};
+	const keyboardMove = (event, deltaX, deltaY) => {
+		if (disposed || active || keyboard || readBoolean(options.isDisabled)) return;
+		const target = eventElement(event);
+		if (!target || event.target !== target) return;
+		event.preventDefault();
+		event.stopPropagation();
+		const step = readKeyboardStep(options.keyboardStep);
+		const errors = [];
+		const current = { target };
+		keyboard = current;
+		moving.value = true;
+		capture(errors, () => options.onMoveStart?.(createMoveEvent("movestart", target, "keyboard", event)));
+		if (keyboard === current && !disposed) capture(errors, () => options.onMove?.(createMoveEvent("move", target, "keyboard", event, deltaX * step, deltaY * step)));
+		if (keyboard === current && !disposed) capture(errors, () => finishKeyboard(event, false));
+		surfaceErrors(errors, "Keyboard move callbacks failed");
+	};
+	const moveProps = Object.freeze({
+		onDragstart(event) {
+			if (active?.target === eventElement(event)) finish(event, true);
+		},
+		onKeydown(event) {
+			if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey) return;
+			switch (event.key) {
+				case "Left":
+				case "ArrowLeft":
+					keyboardMove(event, -1, 0);
+					break;
+				case "Right":
+				case "ArrowRight":
+					keyboardMove(event, 1, 0);
+					break;
+				case "Up":
+				case "ArrowUp":
+					keyboardMove(event, 0, -1);
+					break;
+				case "Down":
+				case "ArrowDown":
+					keyboardMove(event, 0, 1);
+					break;
+			}
+		},
+		onMousedown(event) {
+			if (event.button !== 0 || active || event.view && "PointerEvent" in event.view) return;
+			const elapsed = event.timeStamp - lastTouchTime;
+			if (elapsed >= 0 && elapsed < 800) return;
+			const position = positionOf(event);
+			if (position) start(event, "mouse", "mouse", null, position);
+		},
+		onPointercancel(event) {
+			if (matches("pointer", event.pointerId)) finish(event, true);
+		},
+		onPointerdown(event) {
+			if (!isPrimaryPointer(event)) return;
+			const position = positionOf(event);
+			if (position) start(event, "pointer", pointerTypeOf(event), event.pointerId, position);
+		},
+		onTouchcancel(event) {
+			const current = active?.source === "touch" ? active : null;
+			if (current && positionOf(event, current.id)) finish(event, true);
+		},
+		onTouchend(event) {
+			const current = active?.source === "touch" ? active : null;
+			if (current && positionOf(event, current.id)) finish(event, false);
+		},
+		onTouchmove(event) {
+			const current = active?.source === "touch" ? active : null;
+			const position = current ? positionOf(event, current.id) : null;
+			if (current && position) emitDelta(current, event, position);
+		},
+		onTouchstart(event) {
+			lastTouchTime = event.timeStamp;
+			if (event.view && "PointerEvent" in event.view || active || event.changedTouches.length !== 1) return;
+			const touch = event.changedTouches.item(0);
+			if (touch) start(event, "touch", "touch", touch.identifier, {
+				x: touch.pageX,
+				y: touch.pageY
+			});
+		}
+	});
+	return Object.freeze({
+		isMoving: shallowReadonly(moving),
+		moveProps,
+		cancel: () => {
+			if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+			return finish(null, true) || finishKeyboard(null, true);
+		},
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const current = active;
+			active = null;
+			keyboard = null;
+			moving.value = false;
+			if (!current) return;
+			const errors = [];
+			capture(errors, current.releaseListeners);
+			capture(errors, current.restoreSelection);
+			surfaceErrors(errors, "Move disposal failed");
+		}
+	});
+}
+/** Create a move normalizer disposed with the current Vue effect scope. */
+function useMove(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createMove(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useMove as n, createMove as t };

package/dist/move.d.mts

@@ -0,0 +1,2 @@
+import { a as MoveEvent, c as MovePointerType, d as MoveUpdateEvent, i as MoveEndEvent, l as MoveProps, n as useMove, o as MoveEventType, r as MoveController, s as MoveOptions, t as createMove, u as MoveStartEvent } from "./move-BOmXDYbh.mjs";
+export { type MoveController, type MoveEndEvent, type MoveEvent, type MoveEventType, type MoveOptions, type MovePointerType, type MoveProps, type MoveStartEvent, type MoveUpdateEvent, createMove, useMove };

package/dist/move.mjs

@@ -0,0 +1,2 @@
+import { n as useMove, t as createMove } from "./move-BVvMHzxr.mjs";
+export { createMove, useMove };

package/dist/{press-Bp57IOe2.mjs → press-N_mE3Mgx.mjs}

@@ -1,151 +1,5 @@
-import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
-//#region src/press-event.ts
-const invalidOptionDiagnostic = "VIZE_UI_PRESS_OPTION";
-const pointerTypes = new Set([
-	"keyboard",
-	"mouse",
-	"pen",
-	"pointer",
-	"touch",
-	"virtual"
-]);
-const keyboardBehaviors = new Set([
-	"button",
-	"link",
-	"none"
-]);
-/** Resolve and validate a reactive boolean option for JavaScript consumers. */
-function readBooleanOption(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;
-}
-/** Resolve the closed keyboard behavior union without accepting mistyped JS. */
-function readKeyboardBehavior(value) {
-	const resolved = toValue(value) ?? "button";
-	if (!keyboardBehaviors.has(resolved)) throw new TypeError(`${invalidOptionDiagnostic}: keyboardBehavior must resolve to button, link, or none`);
-	return resolved;
-}
-/** Resolve a cross-realm event currentTarget without instanceof assumptions. */
-function eventElement(event) {
-	const value = event.currentTarget;
-	return value && value.nodeType === 1 ? value : null;
-}
-/** Map Pointer Events' extensible device string to the stable public union. */
-function pointerTypeOf(event) {
-	if (event.pointerId === -1 && event.pointerType === "") return "virtual";
-	if (event.pointerType === "mouse" || event.pointerType === "pen") return event.pointerType;
-	if (event.pointerType === "touch") return "touch";
-	return "pointer";
-}
-/** Only a primary contact and its primary button can activate a control. */
-function isPrimaryPointer(event) {
-	return event.isPrimary !== false && event.button === 0;
-}
-function eventPoint(event, touchIdentifier = null) {
-	if (!event) return null;
-	if ("clientX" in event && "clientY" in event) return {
-		x: Number(event.clientX),
-		y: Number(event.clientY)
-	};
-	if ("changedTouches" in event) {
-		const touches = Array.from(event.changedTouches);
-		const touch = (touchIdentifier === null ? touches[0] : touches.find(({ identifier }) => identifier === touchIdentifier)) ?? null;
-		if (touch) return {
-			x: touch.clientX,
-			y: touch.clientY
-		};
-	}
-	return null;
-}
-function modifier(event, key) {
-	return event && key in event ? Boolean(event[key]) : false;
-}
-/** Build a frozen snapshot so later browser mutation cannot change callbacks' data. */
-function createPressEvent(type, target, pointerType, originalEvent, isCanceled = false, touchIdentifier = null) {
-	if (!pointerTypes.has(pointerType)) throw new TypeError(`${invalidOptionDiagnostic}: invalid press pointer type`);
-	const point = eventPoint(originalEvent, touchIdentifier);
-	return Object.freeze({
-		type,
-		pointerType,
-		target,
-		originalEvent,
-		x: point?.x ?? null,
-		y: point?.y ?? null,
-		altKey: modifier(originalEvent, "altKey"),
-		ctrlKey: modifier(originalEvent, "ctrlKey"),
-		metaKey: modifier(originalEvent, "metaKey"),
-		shiftKey: modifier(originalEvent, "shiftKey"),
-		isCanceled
-	});
-}
-/** Native elements retain their own activation timing and default actions. */
-function keyboardActivation(target, key, behavior) {
-	if (behavior === "none") return null;
-	const tag = target.localName;
-	if (tag === "a" || tag === "area") {
-		if (target.hasAttribute("href")) return key === "Enter" ? "native" : null;
-	}
-	if (tag === "button") return key === "Enter" || key === " " ? "native" : null;
-	if (tag === "summary") return key === "Enter" || key === " " ? "native" : null;
-	if (tag === "input") {
-		const type = (target.getAttribute("type") ?? "text").toLowerCase();
-		if (type === "checkbox" || type === "radio") return key === " " ? "native" : null;
-		return new Set([
-			"button",
-			"file",
-			"image",
-			"reset",
-			"submit"
-		]).has(type) && (key === "Enter" || key === " ") ? "native" : null;
-	}
-	if (behavior === "link") return key === "Enter" ? "custom" : null;
-	return key === "Enter" || key === " " ? "custom" : null;
-}
-/** Determine pointer containment without assuming events originate in one realm. */
-function isEventInside(event, target, touchIdentifier = null) {
-	const point = eventPoint(event, touchIdentifier);
-	if (point) {
-		const hit = target.ownerDocument.elementFromPoint?.(point.x, point.y);
-		if (hit) return hit === target || target.contains(hit);
-	}
-	return event.composedPath().includes(target);
-}
-/** Apply a transient selection guard and return an exact, idempotent restore. */
-function disableTextSelection(target) {
-	if (!("style" in target)) return () => void 0;
-	const style = target.style;
-	if (!style || typeof style.setProperty !== "function") return () => void 0;
-	const properties = ["user-select", "-webkit-user-select"];
-	const previous = properties.map((property) => ({
-		property,
-		value: style.getPropertyValue(property),
-		priority: style.getPropertyPriority(property)
-	}));
-	for (const property of properties) style.setProperty(property, "none");
-	let restored = false;
-	return () => {
-		if (restored) return;
-		restored = true;
-		for (const { property, value, priority } of previous) if (value) style.setProperty(property, value, priority);
-		else style.removeProperty(property);
-	};
-}
-/** Validate callback slots eagerly so setup failures never install listeners. */
-function validatePressOptions(options) {
-	for (const name of [
-		"onPress",
-		"onPressChange",
-		"onPressEnd",
-		"onPressStart",
-		"onPressUp"
-	]) {
-		const callback = options[name];
-		if (callback !== void 0 && typeof callback !== "function") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must be a function`);
-	}
-}
-//#endregion
+import { a as isPrimaryPointer, c as readBooleanOption, i as isEventInside, l as readKeyboardBehavior, n as disableTextSelection, o as keyboardActivation, r as eventElement, s as pointerTypeOf, t as createPressEvent, u as validatePressOptions } from "./press-event-Cd2OPpmw.mjs";
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef } from "vue";
 //#region src/press-handlers.ts
 /** Adapt Pointer Events plus legacy mouse/touch and keyboard events to one lifecycle. */
 function createPressHandlers(lifecycle) {
@@ -612,4 +466,4 @@ function usePress(options = {}) {
 	return controller;
 }
 //#endregion
-export { disableTextSelection as i, usePress as n, createPressEvent as r, createPress as t };
+export { usePress as n, createPress as t };