@tanstack/vue-hotkeys 0.12.1 → 0.14.0

package/dist/useHotkeys.js

@@ -1,139 +1,57 @@
-import { useDefaultHotkeysOptions } from "./HotkeysProviderContext.js";
-import { detectPlatform, getHotkeyManager, normalizeRegisterableHotkey } from "@tanstack/hotkeys";
-import { onUnmounted, unref, watch } from "vue";
+import { useAppHotkeysStoreSource, useDefaultHotkeysOptionsSource } from "./defaultOptions.js";
+import { onScopeDispose, toValue, watch } from "vue";
+import { createHotkeyBindings, prepareHotkeyDefinitions } from "@tanstack/hotkeys/adapter";
 
 //#region src/useHotkeys.ts
+/** Resolves a ref or getter `enabled` so the core sees a boolean. */
+function resolveEnabled(options) {
+	if (!options) return options;
+	const { enabled, ...rest } = options;
+	return enabled === void 0 ? rest : {
+		...rest,
+		enabled: toValue(enabled)
+	};
+}
 /**
-* Vue composable for registering multiple keyboard hotkeys at once.
-*
-* Uses the singleton HotkeyManager for efficient event handling.
-* Accepts a dynamic array of hotkey definitions, making it safe to use
-* with variable-length lists.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
+* Vue composable for registering several hotkeys at once: chords, sequences,
+* and app hotkeys. The list, each hotkey, and options may be refs or getters.
 *
-* @param hotkeys - Array of hotkey definitions to register, or a getter/ref
-* @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options)
+* Options merge in this order: provider defaults, app hotkey declaration,
+* commonOptions, per-hotkey options. Each option applies only to the kinds
+* that support it. Unbound app hotkeys and empty sequences register nothing.
+* A target that resolves to `null` skips registration until it is set.
 *
 * @example
-* ```vue
-* <script setup>
-* import { useHotkeys } from '@tanstack/vue-hotkeys'
-*
+* ```ts
 * useHotkeys([
 *   { hotkey: 'Mod+S', callback: () => save() },
-*   { hotkey: 'Mod+Z', callback: () => undo() },
-*   { hotkey: 'Escape', callback: () => close() },
+*   { hotkey: ['G', 'G'], callback: () => scrollToTop(), options: { timeout: 500 } },
 * ])
-* <\/script>
-* ```
-*
-* @example
-* ```vue
-* <script setup>
-* import { computed } from 'vue'
-* import { useHotkeys } from '@tanstack/vue-hotkeys'
-*
-* const items = computed(() => [...])
-* // Dynamic hotkeys from reactive data
-* useHotkeys(
-*   () => items.value.map((item) => ({
-*     hotkey: item.shortcut,
-*     callback: item.action,
-*     options: { enabled: item.enabled },
-*   })),
-*   { preventDefault: true },
-* )
-* <\/script>
 * ```
 */
 function useHotkeys(hotkeys, commonOptions = {}) {
-	const defaultOptions = useDefaultHotkeysOptions();
-	const manager = getHotkeyManager();
-	const registrations = /* @__PURE__ */ new Map();
+	const defaultOptions = useDefaultHotkeysOptionsSource();
+	const appHotkeys = useAppHotkeysStoreSource();
+	const bindings = createHotkeyBindings();
 	const stopWatcher = watch(() => {
-		const resolvedHotkeys = resolveMaybeRefOrGetter(hotkeys);
-		const resolvedCommonOptions = resolveMaybeRefOrGetter(commonOptions);
-		return resolvedHotkeys.map((def, i) => {
-			const resolvedHotkey = resolveMaybeRefOrGetter(def.hotkey);
-			const resolvedDefOptions = def.options ? resolveMaybeRefOrGetter(def.options) : {};
-			const mergedOptions = {
-				...defaultOptions.hotkey,
-				...resolvedCommonOptions,
-				...resolvedDefOptions
-			};
-			const platform = mergedOptions.platform ?? detectPlatform();
-			const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, platform);
-			const resolvedEnabled = mergedOptions.enabled === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.enabled);
-			const resolvedTarget = mergedOptions.target === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.target);
-			return {
-				index: i,
-				hotkeyString,
-				callback: def.callback,
-				mergedOptions,
-				resolvedEnabled,
-				resolvedTarget
-			};
+		appHotkeys.state.value;
+		const definitions = toValue(hotkeys).map((definition) => ({
+			hotkey: toValue(definition.hotkey),
+			callback: definition.callback,
+			options: resolveEnabled(toValue(definition.options))
+		}));
+		return prepareHotkeyDefinitions(definitions, {
+			appHotkeysStore: appHotkeys.store,
+			defaults: resolveEnabled(defaultOptions().hotkey),
+			commonOptions: resolveEnabled(toValue(commonOptions)),
+			resolveTarget: (target) => toValue(target)
 		});
-	}, (resolved) => {
-		const nextKeys = /* @__PURE__ */ new Set();
-		const prepared = [];
-		for (const entry of resolved) {
-			const finalTarget = entry.resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-			if (!finalTarget) continue;
-			const registrationKey = `${entry.index}:${entry.hotkeyString}`;
-			nextKeys.add(registrationKey);
-			prepared.push({
-				registrationKey,
-				entry,
-				finalTarget
-			});
-		}
-		for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
-			if (record.handle.isActive) record.handle.unregister();
-			registrations.delete(key);
-		}
-		for (const { registrationKey, entry, finalTarget } of prepared) {
-			const existing = registrations.get(registrationKey);
-			if (existing?.handle.isActive && existing.target === finalTarget) {
-				existing.handle.callback = entry.callback;
-				const { target: _target, enabled: _enabled, ...restOptions } = entry.mergedOptions;
-				const optionsWithoutTarget = {
-					...restOptions,
-					...entry.resolvedEnabled === void 0 ? {} : { enabled: entry.resolvedEnabled }
-				};
-				existing.handle.setOptions(optionsWithoutTarget);
-				continue;
-			}
-			if (existing) {
-				if (existing.handle.isActive) existing.handle.unregister();
-				registrations.delete(registrationKey);
-			}
-			const { target: _target, enabled: _enabled, ...restOptions } = entry.mergedOptions;
-			const optionsWithoutTarget = {
-				...restOptions,
-				...entry.resolvedEnabled === void 0 ? {} : { enabled: entry.resolvedEnabled }
-			};
-			const handle = manager.register(entry.hotkeyString, entry.callback, {
-				...optionsWithoutTarget,
-				target: finalTarget
-			});
-			registrations.set(registrationKey, {
-				handle,
-				target: finalTarget
-			});
-		}
-	}, { immediate: true });
-	onUnmounted(() => {
+	}, (definitions) => bindings.update(definitions), { immediate: true });
+	onScopeDispose(() => {
 		stopWatcher();
-		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
-		registrations.clear();
+		bindings.destroy();
 	});
 }
-function resolveMaybeRefOrGetter(value) {
-	return typeof value === "function" ? value() : unref(value);
-}
 
 //#endregion
 export { useHotkeys };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/vue-hotkeys",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "Vue adapter for TanStack Hotkeys",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -36,8 +36,8 @@
     "dist"
   ],
   "dependencies": {
-    "@tanstack/hotkeys": "0.10.1",
-    "@tanstack/vue-store": "^0.11.1"
+    "@tanstack/hotkeys": "0.12.0",
+    "@tanstack/vue-store": "^0.11.2"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.9",

package/dist/useHotkeySequence.d.ts

@@ -1,65 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter } from "vue";
-//#region src/useHotkeySequence.d.ts
-export interface UseHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled' | 'target'> {
-  /**
-   * Whether the sequence is active.
-   * Can be a Ref, a getter function, or a boolean value.
-   * Defaults to true.
-   */
-  enabled?: MaybeRefOrGetter<boolean>;
-  /**
-   * The DOM element to attach the event listener to.
-   * Can be a Ref, a getter function, direct DOM element, or null.
-   * Defaults to document.
-   */
-  target?: MaybeRefOrGetter<HTMLElement | Document | Window | null>;
-}
-/**
- * Vue composable for registering a keyboard shortcut sequence (Vim-style).
- *
- * This composable allows you to register multi-key sequences like 'g g' or 'd d'
- * that trigger when the full sequence is pressed within a timeout.
- *
- * Each step may include modifiers. You can chain the same modifier across
- * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
- * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
- * advance the sequence or reset progress.
- *
- * @param sequence - Array of hotkey strings that form the sequence
- * @param callback - Function to call when the sequence is completed
- * @param options - Options for the sequence behavior
- *
- * @example
- * ```vue
- * <script setup>
- * import { useHotkeySequence } from '@tanstack/vue-hotkeys'
- *
- * // 'g g' to go to top
- * useHotkeySequence(['G', 'G'], () => {
- *   scrollToTop()
- * })
- *
- * // 'd d' to delete line
- * useHotkeySequence(['D', 'D'], () => {
- *   deleteLine()
- * })
- *
- * // 'd i w' to delete inner word
- * useHotkeySequence(['D', 'I', 'W'], () => {
- *   deleteInnerWord()
- * }, { timeout: 500 })
- *
- * // Same modifier on consecutive steps (bare Shift between chords is ignored)
- * useHotkeySequence(['Shift+R', 'Shift+T'], () => {
- *   nextAction()
- * })
- * </script>
- *
- * <template>
- *   <div>...</div>
- * </template>
- * ```
- */
-export declare function useHotkeySequence(sequence: MaybeRefOrGetter<HotkeySequence>, callback: HotkeyCallback, options?: MaybeRefOrGetter<UseHotkeySequenceOptions>): void;
-//#endregion

package/dist/useHotkeySequence.js

@@ -1,121 +0,0 @@
-import { useDefaultHotkeysOptions } from "./HotkeysProviderContext.js";
-import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
-import { onUnmounted, unref, watch } from "vue";
-
-//#region src/useHotkeySequence.ts
-/**
-* Vue composable for registering a keyboard shortcut sequence (Vim-style).
-*
-* This composable allows you to register multi-key sequences like 'g g' or 'd d'
-* that trigger when the full sequence is pressed within a timeout.
-*
-* Each step may include modifiers. You can chain the same modifier across
-* steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
-* Control, Alt, or Meta pressed alone) are ignored while matching—they do not
-* advance the sequence or reset progress.
-*
-* @param sequence - Array of hotkey strings that form the sequence
-* @param callback - Function to call when the sequence is completed
-* @param options - Options for the sequence behavior
-*
-* @example
-* ```vue
-* <script setup>
-* import { useHotkeySequence } from '@tanstack/vue-hotkeys'
-*
-* // 'g g' to go to top
-* useHotkeySequence(['G', 'G'], () => {
-*   scrollToTop()
-* })
-*
-* // 'd d' to delete line
-* useHotkeySequence(['D', 'D'], () => {
-*   deleteLine()
-* })
-*
-* // 'd i w' to delete inner word
-* useHotkeySequence(['D', 'I', 'W'], () => {
-*   deleteInnerWord()
-* }, { timeout: 500 })
-*
-* // Same modifier on consecutive steps (bare Shift between chords is ignored)
-* useHotkeySequence(['Shift+R', 'Shift+T'], () => {
-*   nextAction()
-* })
-* <\/script>
-*
-* <template>
-*   <div>...</div>
-* </template>
-* ```
-*/
-function useHotkeySequence(sequence, callback, options = {}) {
-	const defaultOptions = useDefaultHotkeysOptions();
-	const manager = getSequenceManager();
-	let registration = null;
-	let lastSequenceKey = null;
-	let lastTarget = null;
-	const stopWatcher = watch(() => {
-		const resolvedSequence = resolveMaybeRefOrGetter(sequence);
-		const resolvedOptions = resolveMaybeRefOrGetter(options);
-		const mergedOptions = {
-			...defaultOptions.hotkeySequence,
-			...resolvedOptions
-		};
-		return {
-			resolvedSequence,
-			mergedOptions,
-			resolvedEnabled: mergedOptions.enabled === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.enabled),
-			resolvedTarget: mergedOptions.target === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.target)
-		};
-	}, ({ resolvedSequence, mergedOptions, resolvedEnabled, resolvedTarget }) => {
-		const finalTarget = resolvedTarget === void 0 ? typeof document !== "undefined" ? document : null : resolvedTarget;
-		if (resolvedSequence.length === 0 || !finalTarget) {
-			if (registration?.isActive) {
-				registration.unregister();
-				registration = null;
-			}
-			lastSequenceKey = null;
-			lastTarget = null;
-			return;
-		}
-		const sequenceKey = formatHotkeySequence(resolvedSequence);
-		const { target: _target, enabled: _enabled, ...restOptions } = mergedOptions;
-		const optionsWithoutTarget = {
-			...restOptions,
-			...resolvedEnabled === void 0 ? {} : { enabled: resolvedEnabled }
-		};
-		if (registration?.isActive && lastSequenceKey === sequenceKey && lastTarget === finalTarget) {
-			registration.callback = callback;
-			registration.setOptions(optionsWithoutTarget);
-			return;
-		}
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-		registration = manager.register(resolvedSequence, callback, {
-			...optionsWithoutTarget,
-			target: finalTarget
-		});
-		if (registration.isActive) {
-			registration.callback = callback;
-			registration.setOptions(optionsWithoutTarget);
-		}
-		lastSequenceKey = sequenceKey;
-		lastTarget = finalTarget;
-	}, { immediate: true });
-	onUnmounted(() => {
-		stopWatcher();
-		if (registration?.isActive) {
-			registration.unregister();
-			registration = null;
-		}
-	});
-}
-function resolveMaybeRefOrGetter(value) {
-	return typeof value === "function" ? value() : unref(value);
-}
-
-//#endregion
-export { useHotkeySequence };

package/dist/useHotkeySequenceRecorder.d.ts

@@ -1,17 +0,0 @@
-import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter, Ref } from "vue";
-//#region src/useHotkeySequenceRecorder.d.ts
-export interface VueHotkeySequenceRecorder {
-  isRecording: Ref<boolean>;
-  steps: Ref<HotkeySequence>;
-  recordedSequence: Ref<HotkeySequence | null>;
-  startRecording: () => void;
-  stopRecording: () => void;
-  cancelRecording: () => void;
-  commitRecording: () => void;
-}
-/**
- * Vue composable for recording multi-chord sequences (Vim-style shortcuts).
- */
-export declare function useHotkeySequenceRecorder(options: MaybeRefOrGetter<HotkeySequenceRecorderOptions>): VueHotkeySequenceRecorder;
-//#endregion

package/dist/useHotkeySequenceRecorder.js

@@ -1,44 +0,0 @@
-import { useDefaultHotkeysOptions } from "./HotkeysProviderContext.js";
-import { HotkeySequenceRecorder } from "@tanstack/hotkeys";
-import { onUnmounted, unref, watch } from "vue";
-import { useSelector } from "@tanstack/vue-store";
-
-//#region src/useHotkeySequenceRecorder.ts
-/**
-* Vue composable for recording multi-chord sequences (Vim-style shortcuts).
-*/
-function useHotkeySequenceRecorder(options) {
-	const defaultOptions = useDefaultHotkeysOptions();
-	const recorder = new HotkeySequenceRecorder(resolveHotkeySequenceRecorderOptions(options, defaultOptions));
-	const isRecording = useSelector(recorder.store, (state) => state.isRecording);
-	const steps = useSelector(recorder.store, (state) => state.steps);
-	const recordedSequence = useSelector(recorder.store, (state) => state.recordedSequence);
-	const stopWatcher = watch(() => resolveHotkeySequenceRecorderOptions(options, defaultOptions), (resolvedOptions) => {
-		recorder.setOptions(resolvedOptions);
-	}, { immediate: true });
-	onUnmounted(() => {
-		stopWatcher();
-		recorder.destroy();
-	});
-	return {
-		isRecording,
-		steps,
-		recordedSequence,
-		startRecording: () => recorder.start(),
-		stopRecording: () => recorder.stop(),
-		cancelRecording: () => recorder.cancel(),
-		commitRecording: () => recorder.commit()
-	};
-}
-function resolveHotkeySequenceRecorderOptions(options, defaultOptions) {
-	return {
-		...defaultOptions.hotkeySequenceRecorder,
-		...resolveMaybeRefOrGetter(options)
-	};
-}
-function resolveMaybeRefOrGetter(value) {
-	return typeof value === "function" ? value() : unref(value);
-}
-
-//#endregion
-export { useHotkeySequenceRecorder };

package/dist/useHotkeySequences.d.ts

@@ -1,61 +0,0 @@
-import { UseHotkeySequenceOptions } from "./useHotkeySequence.js";
-import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
-import { MaybeRefOrGetter } from "vue";
-//#region src/useHotkeySequences.d.ts
-/**
- * A single sequence definition for use with `useHotkeySequences`.
- */
-export interface UseHotkeySequenceDefinition {
-  /** Array of hotkey strings that form the sequence */
-  sequence: MaybeRefOrGetter<HotkeySequence>;
-  /** The function to call when the sequence is completed */
-  callback: HotkeyCallback;
-  /** Per-sequence options (merged on top of commonOptions) */
-  options?: MaybeRefOrGetter<UseHotkeySequenceOptions>;
-}
-/**
- * Vue composable for registering multiple keyboard shortcut sequences at once (Vim-style).
- *
- * Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or a getter/ref
- * that returns one, so you can register variable-length lists safely.
- *
- * Options are merged in this order:
- * HotkeysProvider defaults < commonOptions < per-definition options
- *
- * Definitions with an empty `sequence` are skipped (no registration).
- *
- * @param definitions - Array of sequence definitions, or a getter/ref
- * @param commonOptions - Shared options applied to all sequences (overridden by per-definition options)
- *
- * @example
- * ```vue
- * <script setup>
- * import { useHotkeySequences } from '@tanstack/vue-hotkeys'
- *
- * useHotkeySequences([
- *   { sequence: ['G', 'G'], callback: () => scrollToTop() },
- *   { sequence: ['D', 'D'], callback: () => deleteLine() },
- * ])
- * </script>
- * ```
- *
- * @example
- * ```vue
- * <script setup>
- * import { computed } from 'vue'
- * import { useHotkeySequences } from '@tanstack/vue-hotkeys'
- *
- * const items = computed(() => [...])
- * useHotkeySequences(
- *   () => items.value.map((item) => ({
- *     sequence: item.chords,
- *     callback: item.action,
- *     options: { enabled: item.enabled },
- *   })),
- *   { preventDefault: true },
- * )
- * </script>
- * ```
- */
-export declare function useHotkeySequences(definitions: MaybeRefOrGetter<Array<UseHotkeySequenceDefinition>>, commonOptions?: MaybeRefOrGetter<UseHotkeySequenceOptions>): void;
-//#endregion

package/dist/useHotkeySequences.js

@@ -1,139 +0,0 @@
-import { useDefaultHotkeysOptions } from "./HotkeysProviderContext.js";
-import { formatHotkeySequence, getSequenceManager } from "@tanstack/hotkeys";
-import { onUnmounted, unref, watch } from "vue";
-
-//#region src/useHotkeySequences.ts
-/**
-* Vue composable for registering multiple keyboard shortcut sequences at once (Vim-style).
-*
-* Uses the singleton SequenceManager. Accepts a dynamic array of definitions, or a getter/ref
-* that returns one, so you can register variable-length lists safely.
-*
-* Options are merged in this order:
-* HotkeysProvider defaults < commonOptions < per-definition options
-*
-* Definitions with an empty `sequence` are skipped (no registration).
-*
-* @param definitions - Array of sequence definitions, or a getter/ref
-* @param commonOptions - Shared options applied to all sequences (overridden by per-definition options)
-*
-* @example
-* ```vue
-* <script setup>
-* import { useHotkeySequences } from '@tanstack/vue-hotkeys'
-*
-* useHotkeySequences([
-*   { sequence: ['G', 'G'], callback: () => scrollToTop() },
-*   { sequence: ['D', 'D'], callback: () => deleteLine() },
-* ])
-* <\/script>
-* ```
-*
-* @example
-* ```vue
-* <script setup>
-* import { computed } from 'vue'
-* import { useHotkeySequences } from '@tanstack/vue-hotkeys'
-*
-* const items = computed(() => [...])
-* useHotkeySequences(
-*   () => items.value.map((item) => ({
-*     sequence: item.chords,
-*     callback: item.action,
-*     options: { enabled: item.enabled },
-*   })),
-*   { preventDefault: true },
-* )
-* <\/script>
-* ```
-*/
-function useHotkeySequences(definitions, commonOptions = {}) {
-	const defaultOptions = useDefaultHotkeysOptions();
-	const manager = getSequenceManager();
-	const registrations = /* @__PURE__ */ new Map();
-	const stopWatcher = watch(() => {
-		const resolvedDefinitions = resolveMaybeRefOrGetter(definitions);
-		const resolvedCommonOptions = resolveMaybeRefOrGetter(commonOptions);
-		return resolvedDefinitions.map((def, i) => {
-			const resolvedSequence = resolveMaybeRefOrGetter(def.sequence);
-			const resolvedDefOptions = def.options ? resolveMaybeRefOrGetter(def.options) : {};
-			const mergedOptions = {
-				...defaultOptions.hotkeySequence,
-				...resolvedCommonOptions,
-				...resolvedDefOptions
-			};
-			const sequenceString = formatHotkeySequence(resolvedSequence);
-			const resolvedEnabled = mergedOptions.enabled === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.enabled);
-			const resolvedTarget = mergedOptions.target === void 0 ? void 0 : resolveMaybeRefOrGetter(mergedOptions.target);
-			return {
-				index: i,
-				resolvedSequence,
-				sequenceString,
-				callback: def.callback,
-				mergedOptions,
-				resolvedEnabled,
-				resolvedTarget
-			};
-		});
-	}, (resolved) => {
-		const nextKeys = /* @__PURE__ */ new Set();
-		const prepared = [];
-		for (const entry of resolved) {
-			if (entry.resolvedSequence.length === 0) continue;
-			const finalTarget = entry.resolvedTarget ?? (typeof document !== "undefined" ? document : null);
-			if (!finalTarget) continue;
-			const registrationKey = `${entry.index}:${entry.sequenceString}`;
-			nextKeys.add(registrationKey);
-			prepared.push({
-				registrationKey,
-				entry,
-				finalTarget
-			});
-		}
-		for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
-			if (record.handle.isActive) record.handle.unregister();
-			registrations.delete(key);
-		}
-		for (const { registrationKey, entry, finalTarget } of prepared) {
-			const existing = registrations.get(registrationKey);
-			if (existing?.handle.isActive && existing.target === finalTarget) {
-				existing.handle.callback = entry.callback;
-				const { target: _target, enabled: _enabled, ...restOptions } = entry.mergedOptions;
-				const optionsWithoutTarget = {
-					...restOptions,
-					...entry.resolvedEnabled === void 0 ? {} : { enabled: entry.resolvedEnabled }
-				};
-				existing.handle.setOptions(optionsWithoutTarget);
-				continue;
-			}
-			if (existing) {
-				if (existing.handle.isActive) existing.handle.unregister();
-				registrations.delete(registrationKey);
-			}
-			const { target: _target, enabled: _enabled, ...restOptions } = entry.mergedOptions;
-			const optionsWithoutTarget = {
-				...restOptions,
-				...entry.resolvedEnabled === void 0 ? {} : { enabled: entry.resolvedEnabled }
-			};
-			const handle = manager.register(entry.resolvedSequence, entry.callback, {
-				...optionsWithoutTarget,
-				target: finalTarget
-			});
-			registrations.set(registrationKey, {
-				handle,
-				target: finalTarget
-			});
-		}
-	}, { immediate: true });
-	onUnmounted(() => {
-		stopWatcher();
-		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
-		registrations.clear();
-	});
-}
-function resolveMaybeRefOrGetter(value) {
-	return typeof value === "function" ? value() : unref(value);
-}
-
-//#endregion
-export { useHotkeySequences };