@tanstack/svelte-hotkeys 0.11.0 → 0.12.1

package/dist/createHotkeyRecorder.svelte.js

@@ -1,15 +1,3 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _SvelteHotkeyRecorderState_recorder, _SvelteHotkeyRecorderState_subscribe;
 import { HotkeyRecorder } from '@tanstack/hotkeys';
 import { onDestroy } from 'svelte';
 import { getDefaultHotkeysOptions } from './HotkeysCtx';
@@ -51,40 +39,39 @@ import { createStoreSubscriber, resolveMaybeGetter } from './internal.svelte';
  * ```
  */
 class SvelteHotkeyRecorderState {
+    #recorder;
+    #subscribe;
     constructor(options) {
-        _SvelteHotkeyRecorderState_recorder.set(this, void 0);
-        _SvelteHotkeyRecorderState_subscribe.set(this, void 0);
-        // Keep the recorder receiver when used directly as an event handler.
-        this.startRecording = () => {
-            __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").start();
-        };
-        // Keep the recorder receiver when used directly as an event handler.
-        this.stopRecording = () => {
-            __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").stop();
-        };
-        // Keep the recorder receiver when used directly as an event handler.
-        this.cancelRecording = () => {
-            __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").cancel();
-        };
-        __classPrivateFieldSet(this, _SvelteHotkeyRecorderState_recorder, new HotkeyRecorder(options), "f");
-        __classPrivateFieldSet(this, _SvelteHotkeyRecorderState_subscribe, createStoreSubscriber(__classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").store), "f");
+        this.#recorder = new HotkeyRecorder(options);
+        this.#subscribe = createStoreSubscriber(this.#recorder.store);
     }
     get isRecording() {
-        __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").store.state.isRecording;
+        this.#subscribe();
+        return this.#recorder.store.state.isRecording;
     }
     get recordedHotkey() {
-        __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").store.state.recordedHotkey;
+        this.#subscribe();
+        return this.#recorder.store.state.recordedHotkey;
     }
     setOptions(options) {
-        __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").setOptions(options);
+        this.#recorder.setOptions(options);
     }
+    // Keep the recorder receiver when used directly as an event handler.
+    startRecording = () => {
+        this.#recorder.start();
+    };
+    // Keep the recorder receiver when used directly as an event handler.
+    stopRecording = () => {
+        this.#recorder.stop();
+    };
+    // Keep the recorder receiver when used directly as an event handler.
+    cancelRecording = () => {
+        this.#recorder.cancel();
+    };
     destroy() {
-        __classPrivateFieldGet(this, _SvelteHotkeyRecorderState_recorder, "f").destroy();
+        this.#recorder.destroy();
     }
 }
-_SvelteHotkeyRecorderState_recorder = new WeakMap(), _SvelteHotkeyRecorderState_subscribe = new WeakMap();
 export function createHotkeyRecorder(options) {
     const recorder = new SvelteHotkeyRecorderState({
         ...getDefaultHotkeysOptions().hotkeyRecorder,

package/dist/createHotkeySequenceRecorder.svelte.js

@@ -1,62 +1,49 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _SvelteHotkeySequenceRecorderState_recorder, _SvelteHotkeySequenceRecorderState_subscribe;
 import { HotkeySequenceRecorder } from '@tanstack/hotkeys';
 import { onDestroy } from 'svelte';
 import { getDefaultHotkeysOptions } from './HotkeysCtx';
 import { createStoreSubscriber, resolveMaybeGetter } from './internal.svelte';
 class SvelteHotkeySequenceRecorderState {
+    #recorder;
+    #subscribe;
     constructor(options) {
-        _SvelteHotkeySequenceRecorderState_recorder.set(this, void 0);
-        _SvelteHotkeySequenceRecorderState_subscribe.set(this, void 0);
-        // Keep the recorder receiver when used directly as an event handler.
-        this.startRecording = () => {
-            __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").start();
-        };
-        // Keep the recorder receiver when used directly as an event handler.
-        this.stopRecording = () => {
-            __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").stop();
-        };
-        // Keep the recorder receiver when used directly as an event handler.
-        this.cancelRecording = () => {
-            __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").cancel();
-        };
-        // Keep the recorder receiver when used directly as an event handler.
-        this.commitRecording = () => {
-            __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").commit();
-        };
-        __classPrivateFieldSet(this, _SvelteHotkeySequenceRecorderState_recorder, new HotkeySequenceRecorder(options), "f");
-        __classPrivateFieldSet(this, _SvelteHotkeySequenceRecorderState_subscribe, createStoreSubscriber(__classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").store), "f");
+        this.#recorder = new HotkeySequenceRecorder(options);
+        this.#subscribe = createStoreSubscriber(this.#recorder.store);
     }
     get isRecording() {
-        __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").store.state.isRecording;
+        this.#subscribe();
+        return this.#recorder.store.state.isRecording;
     }
     get steps() {
-        __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").store.state.steps;
+        this.#subscribe();
+        return this.#recorder.store.state.steps;
     }
     get recordedSequence() {
-        __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").store.state.recordedSequence;
+        this.#subscribe();
+        return this.#recorder.store.state.recordedSequence;
     }
     setOptions(options) {
-        __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").setOptions(options);
+        this.#recorder.setOptions(options);
     }
+    // Keep the recorder receiver when used directly as an event handler.
+    startRecording = () => {
+        this.#recorder.start();
+    };
+    // Keep the recorder receiver when used directly as an event handler.
+    stopRecording = () => {
+        this.#recorder.stop();
+    };
+    // Keep the recorder receiver when used directly as an event handler.
+    cancelRecording = () => {
+        this.#recorder.cancel();
+    };
+    // Keep the recorder receiver when used directly as an event handler.
+    commitRecording = () => {
+        this.#recorder.commit();
+    };
     destroy() {
-        __classPrivateFieldGet(this, _SvelteHotkeySequenceRecorderState_recorder, "f").destroy();
+        this.#recorder.destroy();
     }
 }
-_SvelteHotkeySequenceRecorderState_recorder = new WeakMap(), _SvelteHotkeySequenceRecorderState_subscribe = new WeakMap();
 /**
  * Svelte helper for recording multi-chord sequences (Vim-style shortcuts).
  */

package/dist/getHeldKeyCodesMap.svelte.js

@@ -1,22 +1,13 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _HeldKeyCodesMapState_tracker, _HeldKeyCodesMapState_subscribe;
 import { getKeyStateTracker } from '@tanstack/hotkeys';
 import { createStoreSubscriber } from './internal.svelte';
 class HeldKeyCodesMapState {
-    constructor() {
-        _HeldKeyCodesMapState_tracker.set(this, getKeyStateTracker());
-        _HeldKeyCodesMapState_subscribe.set(this, createStoreSubscriber(__classPrivateFieldGet(this, _HeldKeyCodesMapState_tracker, "f").store));
-    }
+    #tracker = getKeyStateTracker();
+    #subscribe = createStoreSubscriber(this.#tracker.store);
     get codes() {
-        __classPrivateFieldGet(this, _HeldKeyCodesMapState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _HeldKeyCodesMapState_tracker, "f").store.state.heldCodes;
+        this.#subscribe();
+        return this.#tracker.store.state.heldCodes;
     }
 }
-_HeldKeyCodesMapState_tracker = new WeakMap(), _HeldKeyCodesMapState_subscribe = new WeakMap();
 /**
  * Svelte function that returns reactive access to the map of currently held key names
  * to their physical `event.code` values.

package/dist/getHeldKeys.svelte.js

@@ -1,22 +1,13 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _HeldKeysState_tracker, _HeldKeysState_subscribe;
 import { getKeyStateTracker } from '@tanstack/hotkeys';
 import { createStoreSubscriber } from './internal.svelte';
 class HeldKeysState {
-    constructor() {
-        _HeldKeysState_tracker.set(this, getKeyStateTracker());
-        _HeldKeysState_subscribe.set(this, createStoreSubscriber(__classPrivateFieldGet(this, _HeldKeysState_tracker, "f").store));
-    }
+    #tracker = getKeyStateTracker();
+    #subscribe = createStoreSubscriber(this.#tracker.store);
     get keys() {
-        __classPrivateFieldGet(this, _HeldKeysState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _HeldKeysState_tracker, "f").store.state.heldKeys;
+        this.#subscribe();
+        return this.#tracker.store.state.heldKeys;
     }
 }
-_HeldKeysState_tracker = new WeakMap(), _HeldKeysState_subscribe = new WeakMap();
 /**
  * Svelte function that returns reactive access to currently held keyboard keys.
  *

package/dist/getHotkeyRegistrations.svelte.js

@@ -1,28 +1,19 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _HotkeyRegistrationsState_hotkeyManager, _HotkeyRegistrationsState_sequenceManager, _HotkeyRegistrationsState_subscribeHotkeys, _HotkeyRegistrationsState_subscribeSequences;
 import { getHotkeyManager, getSequenceManager, toHotkeyRegistrationView, } from '@tanstack/hotkeys';
 import { createStoreSubscriber } from './internal.svelte';
 class HotkeyRegistrationsState {
-    constructor() {
-        _HotkeyRegistrationsState_hotkeyManager.set(this, getHotkeyManager());
-        _HotkeyRegistrationsState_sequenceManager.set(this, getSequenceManager());
-        _HotkeyRegistrationsState_subscribeHotkeys.set(this, createStoreSubscriber(__classPrivateFieldGet(this, _HotkeyRegistrationsState_hotkeyManager, "f").registrations));
-        _HotkeyRegistrationsState_subscribeSequences.set(this, createStoreSubscriber(__classPrivateFieldGet(this, _HotkeyRegistrationsState_sequenceManager, "f").registrations));
-    }
+    #hotkeyManager = getHotkeyManager();
+    #sequenceManager = getSequenceManager();
+    #subscribeHotkeys = createStoreSubscriber(this.#hotkeyManager.registrations);
+    #subscribeSequences = createStoreSubscriber(this.#sequenceManager.registrations);
     get hotkeys() {
-        __classPrivateFieldGet(this, _HotkeyRegistrationsState_subscribeHotkeys, "f").call(this);
-        return Array.from(__classPrivateFieldGet(this, _HotkeyRegistrationsState_hotkeyManager, "f").registrations.state.values()).map(toHotkeyRegistrationView);
+        this.#subscribeHotkeys();
+        return Array.from(this.#hotkeyManager.registrations.state.values()).map(toHotkeyRegistrationView);
     }
     get sequences() {
-        __classPrivateFieldGet(this, _HotkeyRegistrationsState_subscribeSequences, "f").call(this);
-        return Array.from(__classPrivateFieldGet(this, _HotkeyRegistrationsState_sequenceManager, "f").registrations.state.values());
+        this.#subscribeSequences();
+        return Array.from(this.#sequenceManager.registrations.state.values());
     }
 }
-_HotkeyRegistrationsState_hotkeyManager = new WeakMap(), _HotkeyRegistrationsState_sequenceManager = new WeakMap(), _HotkeyRegistrationsState_subscribeHotkeys = new WeakMap(), _HotkeyRegistrationsState_subscribeSequences = new WeakMap();
 /**
  * Svelte function that returns reactive access to all hotkey and sequence
  * registrations from the singleton managers.

package/dist/getIsKeyHeld.svelte.js

@@ -1,30 +1,17 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _HeldKeyState_tracker, _HeldKeyState_normalizedKey, _HeldKeyState_subscribe;
 import { getKeyStateTracker } from '@tanstack/hotkeys';
 import { createStoreSubscriber } from './internal.svelte';
 class HeldKeyState {
+    #tracker = getKeyStateTracker();
+    #normalizedKey;
+    #subscribe = createStoreSubscriber(this.#tracker.store);
     constructor(key) {
-        _HeldKeyState_tracker.set(this, getKeyStateTracker());
-        _HeldKeyState_normalizedKey.set(this, void 0);
-        _HeldKeyState_subscribe.set(this, createStoreSubscriber(__classPrivateFieldGet(this, _HeldKeyState_tracker, "f").store));
-        __classPrivateFieldSet(this, _HeldKeyState_normalizedKey, key.toLowerCase(), "f");
+        this.#normalizedKey = key.toLowerCase();
     }
     get held() {
-        __classPrivateFieldGet(this, _HeldKeyState_subscribe, "f").call(this);
-        return __classPrivateFieldGet(this, _HeldKeyState_tracker, "f").store.state.heldKeys.some((heldKey) => heldKey.toLowerCase() === __classPrivateFieldGet(this, _HeldKeyState_normalizedKey, "f"));
+        this.#subscribe();
+        return this.#tracker.store.state.heldKeys.some((heldKey) => heldKey.toLowerCase() === this.#normalizedKey);
     }
 }
-_HeldKeyState_tracker = new WeakMap(), _HeldKeyState_normalizedKey = new WeakMap(), _HeldKeyState_subscribe = new WeakMap();
 /**
  * Svelte function that returns reactive access to whether a specific key is currently being held.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/svelte-hotkeys",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Svelte adapter for TanStack Hotkeys",
   "author": "Kunal Rao",
   "license": "MIT",
@@ -23,7 +23,7 @@
     "shortcuts"
   ],
   "type": "module",
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "module": "dist/index.js",
   "svelte": "./dist/index.js",
   "exports": {
@@ -36,29 +36,31 @@
   },
   "sideEffects": false,
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "dependencies": {
-    "@tanstack/hotkeys": "0.9.0"
+    "@tanstack/hotkeys": "0.10.1"
   },
   "devDependencies": {
-    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
-    "@typescript-eslint/parser": "^8.59.0",
-    "eslint-plugin-svelte": "^3.17.1",
-    "svelte": "^5.55.5"
+    "@typescript-eslint/parser": "^8.70.1",
+    "eslint-plugin-svelte": "^3.23.0",
+    "svelte": "^5.57.1"
   },
   "peerDependencies": {
     "svelte": "^5.25.0"
   },
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "clean": "premove ./dist ./coverage",
     "test:eslint": "eslint ./src",
     "test:lib": "vitest --passWithNoTests",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",
-    "test:build": "publint --strict",
+    "test:build": "publint --strict && node ../../scripts/verify-package.ts",
     "build": "svelte-package --input ./src --output ./dist"
   }
 }

package/src/HotkeysCtx.ts

@@ -1,61 +0,0 @@
-import { createContext } from 'svelte'
-import type {
-  HotkeyRecorderOptions,
-  HotkeySequenceRecorderOptions,
-} from '@tanstack/hotkeys'
-import type { CreateHotkeyOptions } from './createHotkey.svelte'
-import type { Snippet } from 'svelte'
-import type { CreateHotkeySequenceOptions } from './createHotkeySequence.svelte'
-
-export interface HotkeysProviderOptions {
-  hotkey?: Partial<CreateHotkeyOptions>
-  hotkeyRecorder?: Partial<HotkeyRecorderOptions>
-  hotkeySequenceRecorder?: Partial<HotkeySequenceRecorderOptions>
-  hotkeySequence?: Partial<CreateHotkeySequenceOptions>
-}
-
-export interface HotkeysProviderProps {
-  children: Snippet
-  defaultOptions?: HotkeysProviderOptions
-}
-
-export const DEFAULT_OPTIONS: HotkeysProviderOptions = {}
-
-interface HotkeysContextValue {
-  defaultOptions: HotkeysProviderOptions
-}
-
-const [useHotkeysContext, setHotkeysContextValue] =
-  createContext<HotkeysContextValue | null>()
-
-export function setHotkeysContext(
-  defaultOptions: HotkeysProviderOptions = DEFAULT_OPTIONS,
-): HotkeysContextValue {
-  return setHotkeysContextValue({
-    get defaultOptions() {
-      return defaultOptions
-    },
-  })!
-}
-
-export function setHotkeysContextSource(
-  defaultOptions: () => HotkeysProviderOptions,
-): HotkeysContextValue {
-  return setHotkeysContextValue({
-    get defaultOptions() {
-      return defaultOptions()
-    },
-  })!
-}
-
-export function getHotkeysContext(): HotkeysContextValue | null {
-  try {
-    return useHotkeysContext()
-  } catch {
-    return null
-  }
-}
-
-export function getDefaultHotkeysOptions(): HotkeysProviderOptions {
-  return getHotkeysContext()?.defaultOptions ?? DEFAULT_OPTIONS
-}

package/src/HotkeysProvider.svelte

@@ -1,12 +0,0 @@
-<script lang="ts">
-  import { DEFAULT_OPTIONS, setHotkeysContextSource } from './HotkeysCtx'
-
-  import type { HotkeysProviderProps } from './HotkeysCtx'
-
-  let { children, defaultOptions = DEFAULT_OPTIONS }: HotkeysProviderProps =
-    $props()
-
-  setHotkeysContextSource(() => defaultOptions)
-</script>
-
-{@render children()}

package/src/createHotkey.svelte.ts

@@ -1,179 +0,0 @@
-import {
-  detectPlatform,
-  getHotkeyManager,
-  normalizeRegisterableHotkey,
-} from '@tanstack/hotkeys'
-import { onDestroy } from 'svelte'
-import { getDefaultHotkeysOptions } from './HotkeysCtx'
-import { resolveMaybeGetter } from './internal.svelte'
-import type {
-  Hotkey,
-  HotkeyCallback,
-  HotkeyOptions,
-  HotkeyRegistrationHandle,
-  RegisterableHotkey,
-} from '@tanstack/hotkeys'
-import type { MaybeGetter } from './internal.svelte'
-import type { Attachment } from 'svelte/attachments'
-
-export interface CreateHotkeyOptions extends Omit<HotkeyOptions, 'target'> {
-  target?: Document | Window // not html elements, use attachment instead
-}
-
-function registerHotkey(
-  target: HTMLElement | Document | Window,
-  hotkey: RegisterableHotkey,
-  callback: HotkeyCallback,
-  mergedOptions: CreateHotkeyOptions,
-) {
-  return getHotkeyManager().register(
-    normalizeRegisterableHotkey(
-      hotkey,
-      mergedOptions.platform ?? detectPlatform(),
-    ),
-    callback,
-    {
-      ...mergedOptions,
-      target,
-    },
-  )
-}
-
-/**
- * Register a global hotkey for the current component.
- *
- * @example
- * ```svelte
- * <script lang="ts">
- *   import { createHotkey } from '@tanstack/svelte-hotkeys'
- *
- *   createHotkey('Mod+S', () => {
- *     console.log('Mod+S pressed')
- *   })
- * </script>
- * ```
- */
-export function createHotkey(
-  hotkey: MaybeGetter<RegisterableHotkey>,
-  callback: HotkeyCallback,
-  options: MaybeGetter<CreateHotkeyOptions> = {},
-): void {
-  let registration: HotkeyRegistrationHandle | null = null
-  let lastHotkeyStr: Hotkey | null = null
-
-  $effect(() => {
-    if (typeof document === 'undefined') {
-      return
-    }
-
-    const resolvedHotkey = resolveMaybeGetter(hotkey)
-    const resolvedOptions = resolveMaybeGetter(options)
-    const mergedOptions = {
-      ...getDefaultHotkeysOptions().hotkey,
-      ...resolvedOptions,
-    } as CreateHotkeyOptions
-
-    const hotkeyStr = normalizeRegisterableHotkey(
-      resolvedHotkey,
-      mergedOptions.platform ?? detectPlatform(),
-    )
-    const { target: _t, ...optionsWithoutTarget } = mergedOptions
-
-    if (registration?.isActive && lastHotkeyStr === hotkeyStr) {
-      registration.callback = callback
-      registration.setOptions(optionsWithoutTarget)
-      return
-    }
-
-    if (registration?.isActive) {
-      registration.unregister()
-      registration = null
-    }
-
-    registration = registerHotkey(
-      document,
-      resolvedHotkey,
-      callback,
-      mergedOptions,
-    )
-    lastHotkeyStr = hotkeyStr
-  })
-
-  onDestroy(() => {
-    if (registration?.isActive) {
-      registration.unregister()
-      registration = null
-    }
-  })
-}
-
-/**
- * Create an attachment for element-scoped hotkeys.
- *
- * @example
- * ```svelte
- * <script lang="ts">
- *   import { createHotkeyAttachment } from '@tanstack/svelte-hotkeys'
- *
- *   let count = $state(0)
- *   const saveHotkey = createHotkeyAttachment('Mod+S', () => {
- *     count++
- *   })
- *
- * </script>
- *
- * <div tabindex="0" {@attach saveHotkey}>
- *   Count: {count}
- * </div>
- * ```
- */
-export function createHotkeyAttachment(
-  hotkey: MaybeGetter<RegisterableHotkey>,
-  callback: HotkeyCallback,
-  options: MaybeGetter<CreateHotkeyOptions> = {},
-): Attachment<HTMLElement> {
-  return (element) => {
-    let registration: HotkeyRegistrationHandle | null = null
-    let lastHotkeyStr: Hotkey | null = null
-
-    $effect(() => {
-      const resolvedHotkey = resolveMaybeGetter(hotkey)
-      const resolvedOptions = resolveMaybeGetter(options)
-      const mergedOptions = {
-        ...getDefaultHotkeysOptions().hotkey,
-        ...resolvedOptions,
-      } as CreateHotkeyOptions
-
-      const hotkeyStr = normalizeRegisterableHotkey(
-        resolvedHotkey,
-        mergedOptions.platform ?? detectPlatform(),
-      )
-      const { target: _t, ...optionsWithoutTarget } = mergedOptions
-
-      if (registration?.isActive && lastHotkeyStr === hotkeyStr) {
-        registration.callback = callback
-        registration.setOptions(optionsWithoutTarget)
-        return
-      }
-
-      if (registration?.isActive) {
-        registration.unregister()
-        registration = null
-      }
-
-      registration = registerHotkey(
-        element,
-        resolvedHotkey,
-        callback,
-        mergedOptions,
-      )
-      lastHotkeyStr = hotkeyStr
-    })
-
-    return () => {
-      if (registration?.isActive) {
-        registration.unregister()
-      }
-    }
-  }
-}