@vizejs/ui 0.347.7 → 0.351.0

package/dist/press-event-Cd2OPpmw.mjs

@@ -0,0 +1,149 @@
+import { 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
+export { isPrimaryPointer as a, readBooleanOption as c, isEventInside as i, readKeyboardBehavior as l, disableTextSelection as n, keyboardActivation as o, eventElement as r, pointerTypeOf as s, createPressEvent as t, validatePressOptions as u };

package/dist/press.d.mts

@@ -1,4 +1,4 @@
-import { a as PressOptions, i as PressKeyboardBehavior, n as PressEvent, o as PressPointerType, r as PressEventType, s as PressProps, t as PressController } from "./press-types-B8Ssxqg4.mjs";
+import { a as PressOptions, i as PressKeyboardBehavior, n as PressEvent, o as PressPointerType, r as PressEventType, s as PressProps, t as PressController } from "./press-types-CNqStzJf.mjs";
 
 //#region src/press.d.ts
 /**

package/dist/press.mjs

@@ -1,2 +1,2 @@
-import { n as usePress, t as createPress } from "./press-Bp57IOe2.mjs";
+import { n as usePress, t as createPress } from "./press-N_mE3Mgx.mjs";
 export { createPress, usePress };

package/dist/{primitive-BE28SwD7.mjs → primitive-BX31dogp.mjs}

@@ -1,8 +1,8 @@
-import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.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({
+var PrimitiveElement_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
 	__name: "PrimitiveElement",
 	props: { as: {
 		type: null,

package/dist/{primitive-Bog8qvd8.d.mts → primitive-C8jW7DLd.d.mts}

@@ -1,4 +1,3 @@
-import * as _$vue from "vue";
 import { Component, ComponentPublicInstance } from "vue";
 
 //#region src/PrimitiveElement.vue.d.ts
@@ -12,9 +11,9 @@ type __VLS_Props = {
 };
 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_base: import("vue").DefineComponent<__VLS_Props, {
+  element: Readonly<import("vue").ShallowRef<PrimitiveElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 type __VLS_WithSlots<T, S> = T & {

package/dist/primitive.d.mts

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

package/dist/primitive.mjs

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

package/dist/scroll-lock-BgVtX4wT.d.mts

@@ -0,0 +1,49 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/scroll-lock-types.d.ts
+/** Viewport-locking strategy selected for a document. */
+type ScrollLockStrategy = "auto" | "fixed" | "overflow";
+/** Reactive configuration for one document scroll-lock owner. */
+interface ScrollLockOptions {
+  /** Document whose layout viewport is locked. It may be `null` during SSR. */
+  readonly document: MaybeRefOrGetter<Document | null | undefined>;
+  /** Whether an activated controller currently participates in the lock stack. @default true */
+  readonly enabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Lock using root overflow or a fixed body. `auto` uses fixed positioning on iOS-like
+   * touch platforms and root overflow elsewhere.
+   * @default "auto"
+   */
+  readonly strategy?: MaybeRefOrGetter<ScrollLockStrategy | undefined>;
+  /** Reserve a classic scrollbar gutter so viewport-width content does not shift. @default true */
+  readonly preserveScrollbarGap?: MaybeRefOrGetter<boolean | undefined>;
+  /** Restore the captured layout-viewport offset when the final owner releases. @default true */
+  readonly restoreScroll?: MaybeRefOrGetter<boolean | undefined>;
+}
+/** Lifecycle and inspection interface returned by `createScrollLock`. */
+interface ScrollLockController {
+  /** Whether this controller has been activated, independently of reactive enablement. */
+  readonly isActive: Readonly<ShallowRef<boolean>>;
+  /** Whether this controller currently contributes to a document lock. */
+  readonly isLocked: Readonly<ShallowRef<boolean>>;
+  /** Classic scrollbar width measured before the current document lock. */
+  readonly scrollbarGap: Readonly<ShallowRef<number>>;
+  /** Effective strategy after platform resolution and nested-lock composition. */
+  readonly resolvedStrategy: Readonly<ShallowRef<Exclude<ScrollLockStrategy, "auto"> | null>>;
+  /** Join the document lock stack. Safe to call repeatedly. */
+  readonly activate: () => void;
+  /** Leave the lock stack and restore document state when the final owner exits. */
+  readonly deactivate: () => void;
+  /** Re-read reactive options and recover after imperative document changes. */
+  readonly refresh: () => void;
+  /** Permanently release reactive and document-level ownership. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/scroll-lock.d.ts
+/** Lock a reactive document viewport without suppressing browser zoom gestures. */
+declare function createScrollLock(options: ScrollLockOptions): ScrollLockController;
+/** Create, mount-activate, and scope-dispose a document scroll lock. */
+declare function useScrollLock(options: ScrollLockOptions): ScrollLockController;
+//#endregion
+export { ScrollLockStrategy as a, ScrollLockOptions as i, useScrollLock as n, ScrollLockController as r, createScrollLock as t };

package/dist/scroll-lock-Ckbmm0-J.mjs

@@ -0,0 +1,313 @@
+import { getCurrentInstance, getCurrentScope, onMounted, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/scroll-lock-internal.ts
+const optionDiagnostic = "VIZE_UI_SCROLL_LOCK_OPTION";
+function readDocument(source) {
+	const value = toValue(source);
+	if (value === void 0 || value === null) return null;
+	const candidate = value;
+	if (candidate.nodeType !== 9 || candidate.documentElement?.nodeType !== 1) throw new TypeError(`${optionDiagnostic}: document must resolve to a Document or null`);
+	return value;
+}
+function readBoolean(source, name, fallback) {
+	const value = toValue(source);
+	if (value === void 0) return fallback;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: ${name} must resolve to a boolean`);
+	return value;
+}
+function readStrategy(source) {
+	const value = toValue(source) ?? "auto";
+	if (value !== "auto" && value !== "fixed" && value !== "overflow") throw new TypeError(`${optionDiagnostic}: strategy must resolve to "auto", "fixed", or "overflow"`);
+	return value;
+}
+function validateScrollLockOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${optionDiagnostic}: options must be an object`);
+	readDocument(options.document);
+	readBoolean(options.enabled, "enabled", true);
+	readBoolean(options.preserveScrollbarGap, "preserveScrollbarGap", true);
+	readBoolean(options.restoreScroll, "restoreScroll", true);
+	readStrategy(options.strategy);
+}
+//#endregion
+//#region src/scroll-lock-dom.ts
+const rootProperties = [
+	"--vize-scroll-lock-scrollbar-gap",
+	"overflow",
+	"overscroll-behavior",
+	"padding-inline-end",
+	"scrollbar-gutter"
+];
+const bodyProperties = [
+	"left",
+	"position",
+	"top",
+	"width"
+];
+function captureStyle(element, properties) {
+	return {
+		element,
+		properties: properties.map((name) => ({
+			name,
+			priority: element.style.getPropertyPriority(name),
+			value: element.style.getPropertyValue(name)
+		}))
+	};
+}
+function restoreStyle(snapshot) {
+	for (const { name, priority, value } of snapshot.properties) if (value) snapshot.element.style.setProperty(name, value, priority);
+	else snapshot.element.style.removeProperty(name);
+}
+function setOwnedStyle(element, name, value) {
+	element.style.setProperty(name, value, "important");
+}
+function captureDocumentLock(document) {
+	const root = document.documentElement;
+	const body = document.body;
+	if (!root || !body) return null;
+	const view = document.defaultView;
+	return {
+		attribute: root.getAttribute("data-vize-scroll-locked"),
+		body: captureStyle(body, bodyProperties),
+		root: captureStyle(root, rootProperties),
+		scrollX: view?.scrollX ?? 0,
+		scrollY: view?.scrollY ?? 0
+	};
+}
+function measureScrollbarGap(document) {
+	const view = document.defaultView;
+	const clientWidth = document.documentElement?.clientWidth ?? 0;
+	if (!view || clientWidth <= 0 || !Number.isFinite(view.innerWidth)) return 0;
+	return Math.max(0, view.innerWidth - clientWidth);
+}
+function resolveScrollLockStrategy(document, strategy) {
+	if (strategy !== "auto") return strategy;
+	const navigator = document.defaultView?.navigator;
+	const platform = navigator?.platform ?? "";
+	const userAgent = navigator?.userAgent ?? "";
+	return /^(iPad|iPhone|iPod)$/.test(platform) || /\b(iPad|iPhone|iPod)\b/.test(userAgent) || platform === "MacIntel" && (navigator?.maxTouchPoints ?? 0) > 1 ? "fixed" : "overflow";
+}
+function applyDocumentLock(snapshot, strategy, gap, preserveGap) {
+	const root = snapshot.root.element;
+	root.setAttribute("data-vize-scroll-locked", "");
+	setOwnedStyle(root, "--vize-scroll-lock-scrollbar-gap", `${gap}px`);
+	setOwnedStyle(root, "overflow", "hidden");
+	setOwnedStyle(root, "overscroll-behavior", "none");
+	if (preserveGap) {
+		if (root.ownerDocument.defaultView?.CSS?.supports?.("scrollbar-gutter", "stable")) setOwnedStyle(root, "scrollbar-gutter", "stable");
+		else if (gap > 0) {
+			const computed = root.ownerDocument.defaultView?.getComputedStyle(root).paddingInlineEnd;
+			const padding = Number.parseFloat(computed ?? "0");
+			setOwnedStyle(root, "padding-inline-end", `${(Number.isFinite(padding) ? padding : 0) + gap}px`);
+		}
+	}
+	if (strategy === "fixed") {
+		const body = snapshot.body.element;
+		setOwnedStyle(body, "position", "fixed");
+		setOwnedStyle(body, "top", `${-snapshot.scrollY}px`);
+		setOwnedStyle(body, "left", `${-snapshot.scrollX}px`);
+		setOwnedStyle(body, "width", "100%");
+	}
+}
+function restoreDocumentLock(snapshot) {
+	restoreStyle(snapshot.body);
+	restoreStyle(snapshot.root);
+	if (snapshot.attribute === null) snapshot.root.element.removeAttribute("data-vize-scroll-locked");
+	else snapshot.root.element.setAttribute("data-vize-scroll-locked", snapshot.attribute);
+}
+function restoreDocumentScroll(snapshot) {
+	const view = snapshot.root.element.ownerDocument.defaultView;
+	if (!view || typeof view.scrollTo !== "function") return;
+	try {
+		view.scrollTo({
+			behavior: "instant",
+			left: snapshot.scrollX,
+			top: snapshot.scrollY
+		});
+	} catch {}
+}
+//#endregion
+//#region src/scroll-lock-stack.ts
+const states = /* @__PURE__ */ new WeakMap();
+function stateFor(document) {
+	let state = states.get(document);
+	if (!state) {
+		state = {
+			document,
+			restoreOnRelease: true,
+			snapshot: null,
+			tokens: []
+		};
+		states.set(document, state);
+	}
+	return state;
+}
+function restoreAppliedState(state, restoreScroll) {
+	const snapshot = state.snapshot;
+	if (!snapshot) return;
+	restoreDocumentLock(snapshot);
+	if (restoreScroll) restoreDocumentScroll(snapshot);
+}
+function effectiveStrategy(document, tokens) {
+	return tokens.map((token) => resolveScrollLockStrategy(document, token.readStrategy())).includes("fixed") ? "fixed" : "overflow";
+}
+function recomputeScrollLock(state) {
+	const enabled = state.tokens.filter((token) => token.readEnabled());
+	if (enabled.length === 0) {
+		restoreAppliedState(state, state.restoreOnRelease);
+		state.snapshot = null;
+		for (const token of state.tokens) token.setState(false, 0, null);
+		return;
+	}
+	const previous = state.snapshot;
+	if (previous) restoreAppliedState(state, true);
+	const next = captureDocumentLock(state.document);
+	if (!next) {
+		state.snapshot = null;
+		for (const token of state.tokens) token.setState(false, 0, null);
+		return;
+	}
+	state.snapshot = previous ? {
+		...next,
+		scrollX: previous.scrollX,
+		scrollY: previous.scrollY
+	} : next;
+	state.restoreOnRelease = enabled[0]?.readRestoreScroll() ?? true;
+	const strategy = effectiveStrategy(state.document, enabled);
+	const gap = measureScrollbarGap(state.document);
+	const preserveGap = enabled.some((token) => token.readPreserveGap());
+	applyDocumentLock(state.snapshot, strategy, gap, preserveGap);
+	for (const token of state.tokens) {
+		const locked = enabled.includes(token);
+		token.setState(locked, locked ? gap : 0, locked ? strategy : null);
+	}
+}
+function attachScrollLock(token, document) {
+	if (token.document === document) {
+		recomputeScrollLock(stateFor(document));
+		return;
+	}
+	detachScrollLock(token);
+	token.document = document;
+	const state = stateFor(document);
+	state.tokens.push(token);
+	recomputeScrollLock(state);
+}
+function detachScrollLock(token) {
+	const document = token.document;
+	if (!document) {
+		token.setState(false, 0, null);
+		return;
+	}
+	const state = stateFor(document);
+	const index = state.tokens.indexOf(token);
+	if (index >= 0) state.tokens.splice(index, 1);
+	token.document = null;
+	token.setState(false, 0, null);
+	if (state.tokens.length === 0) {
+		restoreAppliedState(state, state.restoreOnRelease);
+		state.snapshot = null;
+		states.delete(document);
+	} else recomputeScrollLock(state);
+}
+function refreshScrollLock(token) {
+	if (token.document) recomputeScrollLock(stateFor(token.document));
+}
+//#endregion
+//#region src/scroll-lock.ts
+const disposedDiagnostic = "VIZE_UI_SCROLL_LOCK_DISPOSED";
+const setupDiagnostic = "VIZE_UI_SCROLL_LOCK_SETUP";
+/** Lock a reactive document viewport without suppressing browser zoom gestures. */
+function createScrollLock(options) {
+	validateScrollLockOptions(options);
+	const activeState = shallowRef(false);
+	const lockedState = shallowRef(false);
+	const gapState = shallowRef(0);
+	const strategyState = shallowRef(null);
+	const token = {
+		document: null,
+		readEnabled: () => readBoolean(options.enabled, "enabled", true),
+		readPreserveGap: () => readBoolean(options.preserveScrollbarGap, "preserveScrollbarGap", true),
+		readRestoreScroll: () => readBoolean(options.restoreScroll, "restoreScroll", true),
+		readStrategy: () => readStrategy(options.strategy),
+		setState: (locked, gap, strategy) => {
+			lockedState.value = locked;
+			gapState.value = gap;
+			strategyState.value = strategy;
+		}
+	};
+	let disposed = false;
+	const assertAlive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const refresh = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		const document = readDocument(options.document);
+		readBoolean(options.enabled, "enabled", true);
+		readBoolean(options.preserveScrollbarGap, "preserveScrollbarGap", true);
+		readBoolean(options.restoreScroll, "restoreScroll", true);
+		readStrategy(options.strategy);
+		if (document && document !== token.document) attachScrollLock(token, document);
+		else if (!document) detachScrollLock(token);
+		else refreshScrollLock(token);
+	};
+	const activate = () => {
+		assertAlive();
+		if (activeState.value) return;
+		activeState.value = true;
+		try {
+			refresh();
+		} catch (error) {
+			activeState.value = false;
+			detachScrollLock(token);
+			throw error;
+		}
+	};
+	const deactivate = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		try {
+			detachScrollLock(token);
+		} finally {
+			activeState.value = false;
+		}
+	};
+	const stopWatch = watch(() => [
+		toValue(options.document),
+		toValue(options.enabled),
+		toValue(options.preserveScrollbarGap),
+		toValue(options.restoreScroll),
+		toValue(options.strategy)
+	], () => {
+		if (activeState.value) refresh();
+	}, { flush: "sync" });
+	return Object.freeze({
+		isActive: shallowReadonly(activeState),
+		isLocked: shallowReadonly(lockedState),
+		scrollbarGap: shallowReadonly(gapState),
+		resolvedStrategy: shallowReadonly(strategyState),
+		activate,
+		deactivate,
+		refresh,
+		dispose: () => {
+			if (disposed) return;
+			try {
+				detachScrollLock(token);
+			} finally {
+				activeState.value = false;
+				disposed = true;
+				stopWatch();
+			}
+		}
+	});
+}
+/** Create, mount-activate, and scope-dispose a document scroll lock. */
+function useScrollLock(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createScrollLock(options);
+	if (getCurrentInstance()) onMounted(controller.activate);
+	else controller.activate();
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useScrollLock as n, createScrollLock as t };

package/dist/scroll-lock.d.mts

@@ -0,0 +1,2 @@
+import { a as ScrollLockStrategy, i as ScrollLockOptions, n as useScrollLock, r as ScrollLockController, t as createScrollLock } from "./scroll-lock-BgVtX4wT.mjs";
+export { type ScrollLockController, type ScrollLockOptions, type ScrollLockStrategy, createScrollLock, useScrollLock };

package/dist/scroll-lock.mjs

@@ -0,0 +1,2 @@
+import { n as useScrollLock, t as createScrollLock } from "./scroll-lock-Ckbmm0-J.mjs";
+export { createScrollLock, useScrollLock };