@vizejs/ui 0.386.0 → 0.388.0

package/dist/shortcut-CvA_o0_F.mjs

@@ -0,0 +1,631 @@
+import { getCurrentScope, isRef, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/families/interaction/shortcut/shortcut-parse.ts
+const parseDiagnostic = "VIZE_UI_SHORTCUT_PATTERN";
+const platformDiagnostic = "VIZE_UI_SHORTCUT_PLATFORM";
+const modifierTokens = new Map([
+	["alt", "alt"],
+	["option", "alt"],
+	["opt", "alt"],
+	["ctrl", "ctrl"],
+	["control", "ctrl"],
+	["meta", "meta"],
+	["cmd", "meta"],
+	["command", "meta"],
+	["win", "meta"],
+	["super", "meta"],
+	["shift", "shift"],
+	["mod", "mod"]
+]);
+const keyAliases = new Map([
+	["esc", "Escape"],
+	["escape", "Escape"],
+	["return", "Enter"],
+	["enter", "Enter"],
+	["space", " "],
+	["spacebar", " "],
+	["plus", "+"],
+	["tab", "Tab"],
+	["backspace", "Backspace"],
+	["delete", "Delete"],
+	["del", "Delete"],
+	["insert", "Insert"],
+	["home", "Home"],
+	["end", "End"],
+	["pageup", "PageUp"],
+	["pagedown", "PageDown"],
+	["up", "ArrowUp"],
+	["arrowup", "ArrowUp"],
+	["down", "ArrowDown"],
+	["arrowdown", "ArrowDown"],
+	["left", "ArrowLeft"],
+	["arrowleft", "ArrowLeft"],
+	["right", "ArrowRight"],
+	["arrowright", "ArrowRight"],
+	["contextmenu", "ContextMenu"],
+	["capslock", "CapsLock"],
+	["numlock", "NumLock"],
+	["scrolllock", "ScrollLock"],
+	["printscreen", "PrintScreen"],
+	["pause", "Pause"]
+]);
+const platforms = new Set(["apple", "standard"]);
+const applePlatformPattern = /mac|iphone|ipad|ipod/i;
+/**
+* Detect the modifier layout of the current environment.
+*
+* Server rendering has no ambient keyboard, so the detector deterministically
+* reports `standard` there; pass an explicit platform when formatting keycaps
+* into server-rendered markup.
+*/
+function detectShortcutPlatform() {
+	const navigatorLike = globalThis.navigator;
+	if (!navigatorLike) return "standard";
+	const surface = `${navigatorLike.platform ?? ""} ${navigatorLike.userAgent ?? ""}`;
+	return applePlatformPattern.test(surface) ? "apple" : "standard";
+}
+function readPlatform(platform) {
+	if (platform === void 0) return detectShortcutPlatform();
+	if (!platforms.has(platform)) throw new TypeError(`${platformDiagnostic}: platform must be "apple" or "standard"`);
+	return platform;
+}
+/** True when the key value is a single character rather than a named key. */
+function isCharacterKeyValue(value) {
+	if (value.length === 0) return false;
+	return value.length === ((value.codePointAt(0) ?? 0) > 65535 ? 2 : 1);
+}
+/** Canonicalize one key token to its `KeyboardEvent.key` value. */
+function normalizeKeyToken(token) {
+	const alias = keyAliases.get(token.toLowerCase());
+	if (alias !== void 0) return alias;
+	if (isCharacterKeyValue(token)) return token.toLowerCase();
+	if (/^f([1-9]|1\d|2[0-4])$/i.test(token)) return token.toUpperCase();
+	return token[0].toUpperCase() + token.slice(1);
+}
+function parseChord(step, platform, pattern) {
+	const tokens = step.split("+");
+	if (tokens.length > 1 && tokens.at(-1) === "" && tokens.at(-2) === "") tokens.splice(-2, 2, "plus");
+	const chord = {
+		key: "",
+		altKey: false,
+		ctrlKey: false,
+		metaKey: false,
+		shiftKey: false
+	};
+	for (const [index, token] of tokens.entries()) {
+		if (token === "") throw new TypeError(`${parseDiagnostic}: empty token in "${pattern}"`);
+		const modifier = modifierTokens.get(token.toLowerCase());
+		if (modifier !== void 0 && index < tokens.length - 1) {
+			const resolved = modifier === "mod" ? platform === "apple" ? "meta" : "ctrl" : modifier;
+			const property = `${resolved}Key`;
+			if (chord[property]) throw new TypeError(`${parseDiagnostic}: duplicate ${resolved} modifier in "${pattern}"`);
+			chord[property] = true;
+			continue;
+		}
+		if (index !== tokens.length - 1) throw new TypeError(`${parseDiagnostic}: "${token}" is not a modifier in "${pattern}"`);
+		chord.key = normalizeKeyToken(token);
+	}
+	if (chord.key === "") throw new TypeError(`${parseDiagnostic}: chord in "${pattern}" is missing a key`);
+	return Object.freeze(chord);
+}
+/**
+* Parse a shortcut pattern into a normalized chord sequence.
+*
+* Chord steps are separated by whitespace and each step joins modifiers and
+* one key with `+`, e.g. `"Mod+K"`, `"Ctrl+Shift+P"`, or `"G D"`. `Mod`
+* resolves to Meta on Apple layouts and Control elsewhere.
+*/
+function parseShortcut(pattern, options = {}) {
+	if (typeof pattern !== "string" || pattern.trim() === "") throw new TypeError(`${parseDiagnostic}: pattern must be a non-empty string`);
+	const platform = readPlatform(options.platform);
+	const steps = pattern.trim().split(/\s+/);
+	return Object.freeze(steps.map((step) => parseChord(step, platform, pattern)));
+}
+const chordShape = [
+	"key",
+	"altKey",
+	"ctrlKey",
+	"metaKey",
+	"shiftKey"
+];
+/** Validate and freeze a caller-supplied sequence without re-parsing. */
+function toShortcutSequence(value, platform) {
+	if (typeof value === "string") return parseShortcut(value, { platform });
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError(`${parseDiagnostic}: shortcut must be a pattern or a non-empty sequence`);
+	return Object.freeze(value.map((chord) => {
+		if (typeof chord?.key !== "string" || chord.key === "") throw new TypeError(`${parseDiagnostic}: every chord must carry a non-empty key`);
+		for (const property of chordShape.slice(1)) if (typeof chord[property] !== "boolean") throw new TypeError(`${parseDiagnostic}: chord ${String(property)} must be a boolean`);
+		return Object.freeze({
+			key: isCharacterKeyValue(chord.key) ? chord.key.toLowerCase() : chord.key,
+			altKey: chord.altKey,
+			ctrlKey: chord.ctrlKey,
+			metaKey: chord.metaKey,
+			shiftKey: chord.shiftKey
+		});
+	}));
+}
+/** Stable identity string used for routing and conflict detection. */
+function serializeShortcut(sequence) {
+	return sequence.map((chord) => [
+		chord.altKey ? "Alt+" : "",
+		chord.ctrlKey ? "Ctrl+" : "",
+		chord.metaKey ? "Meta+" : "",
+		chord.shiftKey ? "Shift+" : "",
+		chord.key === "+" ? "Plus" : chord.key
+	].join("")).join(" ");
+}
+const modifierKeys = new Set([
+	"Alt",
+	"AltGraph",
+	"Control",
+	"Meta",
+	"Shift",
+	"OS"
+]);
+/** True when the event is a lone modifier press that can never end a chord. */
+function isModifierOnlyEvent(event) {
+	return modifierKeys.has(event.key);
+}
+/** Build the normalized chord described by one keyboard event. */
+function chordFromEvent(event) {
+	const key = typeof event.key === "string" ? event.key : "";
+	return Object.freeze({
+		key: isCharacterKeyValue(key) ? key.toLowerCase() : key,
+		altKey: event.altKey === true,
+		ctrlKey: event.ctrlKey === true,
+		metaKey: event.metaKey === true,
+		shiftKey: event.shiftKey === true
+	});
+}
+//#endregion
+//#region src/families/interaction/shortcut/shortcut-registry.ts
+const optionDiagnostic$1 = "VIZE_UI_SHORTCUT_OPTION";
+function readOptionalBoolean(value, name) {
+	if (value === void 0) return false;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic$1}: ${name} must be a boolean`);
+	return value;
+}
+function validateBindingStatics(options) {
+	if (typeof options.handler !== "function") throw new TypeError(`${optionDiagnostic$1}: handler must be a function`);
+	if (options.scope !== void 0 && (typeof options.scope !== "string" || options.scope === "")) throw new TypeError(`${optionDiagnostic$1}: scope must be a non-empty string`);
+	if (options.description !== void 0 && typeof options.description !== "string") throw new TypeError(`${optionDiagnostic$1}: description must be a string`);
+	readOptionalBoolean(options.allowRepeat, "allowRepeat");
+	readOptionalBoolean(options.allowInEditable, "allowInEditable");
+	if (options.preventDefault !== void 0 && typeof options.preventDefault !== "boolean") throw new TypeError(`${optionDiagnostic$1}: preventDefault must be a boolean`);
+}
+function readWhen(binding) {
+	const value = toValue(binding.when);
+	if (value === void 0) return true;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic$1}: when must resolve to a boolean`);
+	return value;
+}
+function chordEquals(left, right) {
+	if (left.altKey !== right.altKey || left.ctrlKey !== right.ctrlKey || left.metaKey !== right.metaKey || left.shiftKey !== right.shiftKey) return false;
+	return isCharacterKeyValue(left.key) ? left.key === right.key : left.key.toLowerCase() === right.key.toLowerCase();
+}
+const nonTextInputTypes = new Set([
+	"button",
+	"checkbox",
+	"color",
+	"file",
+	"image",
+	"radio",
+	"range",
+	"reset",
+	"submit"
+]);
+/** Detect text-editing targets across light and shadow DOM retargeting. */
+function isEditableEventTarget(event) {
+	const path = typeof event.composedPath === "function" ? event.composedPath() : [];
+	const target = path.length > 0 ? path[0] : event.target;
+	if (!target || target.nodeType !== 1) return false;
+	const element = target;
+	if (element.isContentEditable === true) return true;
+	const tag = element.tagName;
+	if (tag === "TEXTAREA" || tag === "SELECT") return true;
+	if (tag === "INPUT") return !nonTextInputTypes.has(element.type);
+	return false;
+}
+function scopeDepth(scope, activeScopes) {
+	if (scope === "global") return -1;
+	return activeScopes.lastIndexOf(scope);
+}
+function isCandidate(binding, activeScopes, isEditable, isRepeat) {
+	if (binding.scope !== "global" && !activeScopes.includes(binding.scope)) return false;
+	if (isEditable && !binding.allowInEditable) return false;
+	if (isRepeat && !(binding.allowRepeat && binding.sequence.length === 1)) return false;
+	return readWhen(binding);
+}
+function startsWith(sequence, prefix) {
+	return prefix.every((chord, index) => chordEquals(sequence[index], chord));
+}
+/**
+* Route one accepted chord against the registered bindings.
+*
+* Exact matches win over pending extensions. Among exact matches the binding
+* in the most recently activated scope wins, and within one scope the most
+* recently registered binding wins.
+*/
+function routeChord(bindings, activeScopes, next, context) {
+	let winner = null;
+	let winnerDepth = Number.NEGATIVE_INFINITY;
+	let pendingPreventDefault = false;
+	let hasPrefix = false;
+	for (const binding of bindings) {
+		if (binding.sequence.length < next.length) continue;
+		if (!startsWith(binding.sequence, next)) continue;
+		if (!isCandidate(binding, activeScopes, context.isEditable, context.isRepeat)) continue;
+		if (binding.sequence.length > next.length) {
+			hasPrefix = true;
+			if (binding.preventDefault) pendingPreventDefault = true;
+			continue;
+		}
+		const depth = scopeDepth(binding.scope, activeScopes);
+		if (winner === null || depth > winnerDepth || depth === winnerDepth && binding.order > winner.order) {
+			winner = binding;
+			winnerDepth = depth;
+		}
+	}
+	if (winner !== null) return {
+		type: "match",
+		binding: winner
+	};
+	if (hasPrefix) return {
+		type: "pending",
+		preventDefault: pendingPreventDefault
+	};
+	return { type: "none" };
+}
+function toBindingInfo(binding) {
+	return Object.freeze({
+		shortcut: binding.sequence,
+		scope: binding.scope,
+		description: binding.description
+	});
+}
+/** Group same-scope bindings that claim one identical normalized sequence. */
+function collectConflicts(bindings) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const binding of bindings) {
+		const groupKey = `${binding.scope}${binding.sequenceId}`;
+		const group = groups.get(groupKey);
+		if (group) group.push(binding);
+		else groups.set(groupKey, [binding]);
+	}
+	const conflicts = [];
+	for (const group of groups.values()) {
+		if (group.length < 2) continue;
+		const [first] = group;
+		conflicts.push(Object.freeze({
+			scope: first.scope,
+			shortcut: first.sequence,
+			bindings: Object.freeze(group.map(toBindingInfo))
+		}));
+	}
+	return Object.freeze(conflicts);
+}
+//#endregion
+//#region src/families/interaction/shortcut/shortcut-format.ts
+const symbolModifiers = {
+	apple: [
+		["ctrlKey", "⌃"],
+		["altKey", "⌥"],
+		["shiftKey", "⇧"],
+		["metaKey", "⌘"]
+	],
+	standard: [
+		["ctrlKey", "Ctrl"],
+		["altKey", "Alt"],
+		["shiftKey", "Shift"],
+		["metaKey", "Meta"]
+	]
+};
+const textModifiers = {
+	apple: [
+		["ctrlKey", "Control"],
+		["altKey", "Option"],
+		["shiftKey", "Shift"],
+		["metaKey", "Command"]
+	],
+	standard: symbolModifiers.standard
+};
+const symbolKeys = new Map([
+	["Enter", "↩"],
+	["Backspace", "⌫"],
+	["Delete", "⌦"],
+	["Escape", "⎋"],
+	["Tab", "⇥"],
+	["CapsLock", "⇪"]
+]);
+const sharedKeycaps = new Map([
+	["ArrowUp", "↑"],
+	["ArrowDown", "↓"],
+	["ArrowLeft", "←"],
+	["ArrowRight", "→"],
+	[" ", "Space"]
+]);
+const textKeys = new Map([["Escape", "Esc"]]);
+function keycapForKey(key, platform, style) {
+	const shared = sharedKeycaps.get(key);
+	if (shared !== void 0) return shared;
+	if (style === "symbol" && platform === "apple") {
+		const symbol = symbolKeys.get(key);
+		if (symbol !== void 0) return symbol;
+	}
+	const text = textKeys.get(key);
+	if (text !== void 0) return text;
+	return isCharacterKeyValue(key) ? key.toUpperCase() : key;
+}
+function chordKeycaps(chord, platform, style) {
+	const modifiers = style === "symbol" ? symbolModifiers[platform] : textModifiers[platform];
+	const keycaps = [];
+	for (const [property, keycap] of modifiers) if (chord[property]) keycaps.push(keycap);
+	keycaps.push(keycapForKey(chord.key, platform, style));
+	return Object.freeze(keycaps);
+}
+function resolveDisplay(options) {
+	const platform = readPlatform(options.platform);
+	const style = options.style ?? (platform === "apple" ? "symbol" : "text");
+	if (style !== "symbol" && style !== "text") throw new TypeError("VIZE_UI_SHORTCUT_FORMAT: style must be \"symbol\" or \"text\"");
+	return {
+		platform,
+		style
+	};
+}
+/**
+* Break a shortcut into display keycaps for `<kbd>` rendering.
+*
+* The result carries one array per sequence step; each step lists modifier
+* keycaps in platform order followed by the key keycap. Formatting is
+* deterministic for a given platform, so pass an explicit platform when the
+* output is server-rendered.
+*/
+function getShortcutKeycaps(shortcut, options = {}) {
+	const { platform, style } = resolveDisplay(options);
+	const sequence = typeof shortcut === "string" ? parseShortcut(shortcut, { platform }) : toShortcutSequence(shortcut, platform);
+	return Object.freeze(sequence.map((chord) => chordKeycaps(chord, platform, style)));
+}
+/**
+* Format a shortcut as one display string, e.g. `⇧⌘K` or `Ctrl+Shift+K`.
+*
+* Apple symbol keycaps join without separators; every other combination joins
+* with `+`. Sequence steps are joined with a single space.
+*/
+function formatShortcut(shortcut, options = {}) {
+	const { platform, style } = resolveDisplay(options);
+	const joiner = platform === "apple" && style === "symbol" ? "" : "+";
+	return getShortcutKeycaps(shortcut, {
+		platform,
+		style
+	}).map((keycaps) => keycaps.join(joiner)).join(" ");
+}
+//#endregion
+//#region src/families/interaction/shortcut/shortcut.ts
+const disposedDiagnostic = "VIZE_UI_SHORTCUT_DISPOSED";
+const setupDiagnostic = "VIZE_UI_SHORTCUT_SETUP";
+const optionDiagnostic = "VIZE_UI_SHORTCUT_OPTION";
+const inputDiagnostic = "VIZE_UI_SHORTCUT_INPUT";
+const emptySequence = Object.freeze([]);
+const emptyScopes = Object.freeze([]);
+function defaultDocument() {
+	return typeof globalThis.document === "undefined" ? null : globalThis.document;
+}
+function readTimeout(source) {
+	const value = toValue(source) ?? 1e3;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new TypeError(`${optionDiagnostic}: sequenceTimeout must resolve to a finite number >= 0`);
+	return value;
+}
+function readDisabled(source) {
+	const value = toValue(source);
+	if (value === void 0) return false;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: isDisabled must resolve to a boolean`);
+	return value;
+}
+function toEventTarget(value) {
+	if (value === void 0) return defaultDocument();
+	if (value === null) return null;
+	if (typeof value.addEventListener !== "function" || typeof value.removeEventListener !== "function") throw new TypeError(`${optionDiagnostic}: target must resolve to an EventTarget or null`);
+	return value;
+}
+/**
+* Create an SSR-safe, scope-aware keyboard shortcut registry.
+*
+* The registry resolves `Mod` for one platform, routes chords and multi-chord
+* sequences to the winning binding, and never touches the DOM on the server:
+* with no ambient document it stays detached until a target appears or events
+* are fed through {@link ShortcutRegistry.input}. Call
+* {@link ShortcutRegistry.dispose} when using this factory outside a Vue
+* effect scope.
+*/
+function createShortcutRegistry(options = {}) {
+	const platform = readPlatform(options.platform);
+	const capture = readOptionalBoolean(options.capture, "capture");
+	readTimeout(options.sequenceTimeout);
+	readDisabled(options.isDisabled);
+	const pendingSequence = shallowRef(emptySequence);
+	const activeScopes = shallowRef(emptyScopes);
+	const bindings = /* @__PURE__ */ new Map();
+	const scopeStack = [];
+	const detachers = /* @__PURE__ */ new Set();
+	let timer = null;
+	let order = 0;
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the registry has been disposed`);
+	};
+	const clearTimer = () => {
+		if (timer !== null) clearTimeout(timer);
+		timer = null;
+	};
+	const reset = () => {
+		clearTimer();
+		if (pendingSequence.value.length === 0) return false;
+		pendingSequence.value = emptySequence;
+		return true;
+	};
+	const scheduleReset = (timeout) => {
+		clearTimer();
+		timer = setTimeout(() => {
+			pendingSequence.value = emptySequence;
+			timer = null;
+		}, timeout);
+	};
+	const route = (event, pending) => {
+		const chord = chordFromEvent(event);
+		const next = Object.freeze([...pending, chord]);
+		let decision;
+		try {
+			decision = routeChord(bindings.values(), activeScopes.value, next, {
+				isEditable: isEditableEventTarget(event),
+				isRepeat: event.repeat === true
+			});
+		} catch (error) {
+			reset();
+			throw error;
+		}
+		if (decision.type === "match") {
+			reset();
+			if (decision.binding.preventDefault) event.preventDefault();
+			const match = Object.freeze({
+				shortcut: decision.binding.sequence,
+				scope: decision.binding.scope,
+				description: decision.binding.description,
+				originalEvent: event
+			});
+			decision.binding.handler(match);
+			return true;
+		}
+		if (decision.type === "pending") {
+			pendingSequence.value = next;
+			scheduleReset(readTimeout(options.sequenceTimeout));
+			if (decision.preventDefault) event.preventDefault();
+			return false;
+		}
+		if (pending.length > 0) {
+			reset();
+			return route(event, emptySequence);
+		}
+		return false;
+	};
+	const input = (event) => {
+		assertActive();
+		if (!event || typeof event.key !== "string") throw new TypeError(`${inputDiagnostic}: input requires a keyboard event`);
+		let disabled;
+		try {
+			disabled = readDisabled(options.isDisabled);
+		} catch (error) {
+			reset();
+			throw error;
+		}
+		if (disabled) {
+			reset();
+			return false;
+		}
+		if (event.isComposing === true || isModifierOnlyEvent(event)) return false;
+		return route(event, pendingSequence.value);
+	};
+	const nativeListener = (event) => {
+		input(event);
+	};
+	const attach = (target, attachOptions = {}) => {
+		assertActive();
+		const resolved = toEventTarget(target ?? null);
+		if (resolved === null) throw new TypeError(`${optionDiagnostic}: attach requires an EventTarget`);
+		const useCapture = attachOptions.capture ?? capture;
+		resolved.addEventListener("keydown", nativeListener, useCapture);
+		let detached = false;
+		const detach = () => {
+			if (detached) return;
+			detached = true;
+			detachers.delete(detach);
+			resolved.removeEventListener("keydown", nativeListener, useCapture);
+		};
+		detachers.add(detach);
+		return detach;
+	};
+	let detachPrimary = null;
+	const attachPrimary = () => {
+		detachPrimary?.();
+		detachPrimary = null;
+		const target = toEventTarget(toValue(options.target));
+		if (target !== null) detachPrimary = attach(target);
+	};
+	const stopWatches = [];
+	const targetSource = options.target;
+	if (isRef(targetSource) || typeof targetSource === "function") stopWatches.push(watch(() => toValue(targetSource), attachPrimary, { flush: "sync" }));
+	attachPrimary();
+	const disabledSource = options.isDisabled;
+	if (isRef(disabledSource) || typeof disabledSource === "function") stopWatches.push(watch(() => readDisabled(disabledSource), (value) => {
+		if (value) reset();
+	}, { flush: "sync" }));
+	return Object.freeze({
+		pendingSequence: shallowReadonly(pendingSequence),
+		activeScopes: shallowReadonly(activeScopes),
+		shortcutProps: Object.freeze({ onKeydown(event) {
+			input(event);
+		} }),
+		register(binding) {
+			assertActive();
+			validateBindingStatics(binding);
+			const key = Symbol("vize-ui-shortcut-binding");
+			const sequence = toShortcutSequence(binding.shortcut, platform);
+			bindings.set(key, {
+				sequence,
+				sequenceId: serializeShortcut(sequence),
+				scope: binding.scope ?? "global",
+				handler: binding.handler,
+				when: binding.when,
+				preventDefault: binding.preventDefault ?? true,
+				allowRepeat: readOptionalBoolean(binding.allowRepeat, "allowRepeat"),
+				allowInEditable: readOptionalBoolean(binding.allowInEditable, "allowInEditable"),
+				description: binding.description ?? null,
+				order: order++
+			});
+			return () => {
+				bindings.delete(key);
+			};
+		},
+		activateScope(scope) {
+			assertActive();
+			if (typeof scope !== "string" || scope === "" || scope === "global") throw new TypeError(`${optionDiagnostic}: scope must be a non-empty, non-global name`);
+			const token = Symbol("vize-ui-shortcut-scope");
+			scopeStack.push({
+				name: scope,
+				token
+			});
+			activeScopes.value = Object.freeze(scopeStack.map((entry) => entry.name));
+			return () => {
+				const index = scopeStack.findIndex((entry) => entry.token === token);
+				if (index === -1) return;
+				scopeStack.splice(index, 1);
+				activeScopes.value = Object.freeze(scopeStack.map((entry) => entry.name));
+			};
+		},
+		input,
+		attach,
+		reset: () => {
+			assertActive();
+			return reset();
+		},
+		getBindings: () => Object.freeze([...bindings.values()].map(toBindingInfo)),
+		getConflicts: () => collectConflicts(bindings.values()),
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			for (const stop of stopWatches) stop();
+			for (const detach of Array.from(detachers)) detach();
+			detachPrimary = null;
+			clearTimer();
+			pendingSequence.value = emptySequence;
+			bindings.clear();
+		}
+	});
+}
+/** Create a shortcut registry disposed with the current Vue effect scope. */
+function useShortcutRegistry(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const registry = createShortcutRegistry(options);
+	onScopeDispose(registry.dispose);
+	return registry;
+}
+//#endregion
+export { detectShortcutPlatform as a, getShortcutKeycaps as i, useShortcutRegistry as n, parseShortcut as o, formatShortcut as r, serializeShortcut as s, createShortcutRegistry as t };