@tanstack/hotkeys 0.7.1 → 0.9.0

package/src/{manager.utils.ts → _event-target.ts}

@@ -1,38 +1,3 @@
-import type { ParsedHotkey } from './hotkey'
-
-/**
- * Behavior when registering a hotkey/sequence that conflicts with an existing registration.
- *
- * - `'warn'` - Log a warning to the console but allow both registrations (default)
- * - `'error'` - Throw an error and prevent the new registration
- * - `'replace'` - Unregister the existing registration and register the new one
- * - `'allow'` - Allow multiple registrations without warning
- */
-export type ConflictBehavior = 'warn' | 'error' | 'replace' | 'allow'
-
-/**
- * Default options for hotkey/sequence registration.
- * Omitted: platform, target (resolved at registration), requireReset (HotkeyManager only).
- */
-export const defaultHotkeyOptions = {
-  preventDefault: true,
-  stopPropagation: true,
-  eventType: 'keydown' as const,
-  enabled: true,
-  ignoreInputs: true,
-  conflictBehavior: 'warn' as ConflictBehavior,
-}
-
-/**
- * Computes the default ignoreInputs value based on the hotkey.
- * Ctrl/Meta shortcuts and Escape fire in inputs; single keys and Shift/Alt combos are ignored.
- */
-export function getDefaultIgnoreInputs(parsedHotkey: ParsedHotkey): boolean {
-  if (parsedHotkey.ctrl || parsedHotkey.meta) return false // Mod+S, Ctrl+C, etc.
-  if (parsedHotkey.key === 'Escape') return false // Close modal, etc.
-  return true // Single keys, Shift+key, Alt+key
-}
-
 /**
  * Checks if an element is an input-like element that should be ignored for hotkeys.
  *
@@ -190,42 +155,3 @@ export function isEventForTarget(
 
   return false
 }
-
-/**
- * Handles conflicts between registrations based on conflict behavior.
- *
- * @param conflictingId - The ID of the conflicting registration
- * @param keyDisplay - Display string for the conflicting key/sequence (for error messages)
- * @param conflictBehavior - How to handle the conflict
- * @param unregister - Function to unregister by ID
- */
-export function handleConflict(
-  conflictingId: string,
-  keyDisplay: string,
-  conflictBehavior: ConflictBehavior,
-  unregister: (id: string) => void,
-): void {
-  if (conflictBehavior === 'allow') {
-    return
-  }
-
-  if (conflictBehavior === 'warn') {
-    console.warn(
-      `'${keyDisplay}' is already registered. Multiple handlers will be triggered. ` +
-        `Use conflictBehavior: 'replace' to replace the existing handler, ` +
-        `or conflictBehavior: 'allow' to suppress this warning.`,
-    )
-    return
-  }
-
-  if (conflictBehavior === 'error') {
-    throw new Error(
-      `'${keyDisplay}' is already registered. ` +
-        `Use conflictBehavior: 'replace' to replace the existing handler, ` +
-        `or conflictBehavior: 'allow' to allow multiple registrations.`,
-    )
-  }
-
-  // At this point, conflictBehavior must be 'replace'
-  unregister(conflictingId)
-}

package/src/_keyboard-event.ts

@@ -0,0 +1,101 @@
+import { PUNCTUATION_CODE_MAP, normalizeKeyName } from './constants'
+import type { NormalizedKeyboardEvent } from './key.types'
+
+/** Normalizes Unicode key names and modifier flags while retaining physical code and IME state. */
+export function normalizeKeyboardEvent(
+  event: KeyboardEvent,
+  platform?: 'mac' | 'windows' | 'linux',
+): NormalizedKeyboardEvent {
+  let altGraph = false
+  try {
+    // WebKit reports AltGraph for Option on some macOS keyboard layouts. Option
+    // remains a normal Alt shortcut modifier there, so only use this signal on
+    // Windows/Linux where AltGraph synthesizes Control+Alt.
+    altGraph =
+      platform !== 'mac' &&
+      typeof event.getModifierState === 'function' &&
+      event.getModifierState('AltGraph')
+  } catch {
+    // Synthetic events and older browsers may not implement this reliably.
+  }
+
+  const key = (event.key || '').normalize('NFC')
+  return {
+    key: normalizeKeyName(key),
+    code: event.code || '',
+    ctrl: Boolean(event.ctrlKey),
+    shift: Boolean(event.shiftKey),
+    alt: Boolean(event.altKey),
+    meta: Boolean(event.metaKey),
+    altGraph,
+    location: event.location,
+    isComposing:
+      Boolean(event.isComposing) || key === 'Process' || key === 'Unidentified',
+  }
+}
+
+/**
+ * Maps familiar positions to compatibility fallback keys for the logical matcher.
+ * This assumes conventional positions, not the active layout; never use it to
+ * turn recorded physical bindings into logical bindings or display labels.
+ */
+export function codeToLogicalKey(code: string): string | undefined {
+  if (/^Key[A-Z]$/i.test(code)) return code.slice(3).toUpperCase()
+  if (/^Digit[0-9]$/i.test(code)) return code.slice(5)
+  if (/^Numpad[0-9]$/i.test(code)) return code.slice(6)
+
+  const punctuation = PUNCTUATION_CODE_MAP[code]
+  if (punctuation) return punctuation
+
+  const named: Record<string, string> = {
+    NumpadAdd: '+',
+    NumpadSubtract: '-',
+    NumpadMultiply: '*',
+    NumpadDivide: '/',
+    NumpadDecimal: '.',
+    NumpadEnter: 'Enter',
+    Space: 'Space',
+  }
+  return named[code]
+}
+
+/** Tests for one Unicode code point, including characters represented by a surrogate pair. */
+export function isPrintableKey(key: string): boolean {
+  return key !== '' && Array.from(key).length === 1
+}
+
+/** Splits modifier tokens while retaining a trailing literal plus: `Control++` → `['Control', '+']`. */
+export function splitHotkeyParts(hotkey: string): Array<string> {
+  if (!hotkey.endsWith('+')) return hotkey.split('+')
+  const parts = hotkey.slice(0, -1).split('+')
+  if (parts.at(-1) === '') parts.pop()
+  parts.push('+')
+  return parts
+}
+
+/** Identifies ASCII letters whose layout-produced value takes precedence over positional fallbacks. */
+export function isAsciiLetter(key: string): boolean {
+  return /^[A-Za-z]$/.test(key)
+}
+
+/** Identifies a single Latin-script character, including accented letters. */
+export function isLatinLetter(key: string): boolean {
+  return /^\p{Script_Extensions=Latin}$/u.test(key)
+}
+
+/** Compares letters without case, preserving accents and avoiding expansions such as ß → SS. */
+export function keysEqual(left: string, right: string): boolean {
+  if (/^\p{Letter}$/u.test(left) && /^\p{Letter}$/u.test(right)) {
+    return left.localeCompare(right, undefined, { sensitivity: 'accent' }) === 0
+  }
+  return left === right
+}
+
+/** Rejects reserved physical-token syntax in logical object fields while allowing Unicode characters. */
+export function assertLogicalKey(key: string): void {
+  if (/^\[.*\]$/s.test(key.trim())) {
+    throw new Error(
+      'Logical key must not contain a bracketed physical code. Use the code field instead.',
+    )
+  }
+}

package/src/_match.ts

@@ -0,0 +1,96 @@
+import { detectPlatform } from './platform'
+import {
+  codeToLogicalKey,
+  isAsciiLetter,
+  isLatinLetter,
+  isPrintableKey,
+  keysEqual,
+  normalizeKeyboardEvent,
+} from './_keyboard-event'
+import { parseHotkey } from './parse'
+import type { KeyboardEventMatch } from './match'
+import type { Hotkey, ParsedHotkey } from './hotkey.types'
+
+/** Matches an event and reports the winning candidate and release identity. */
+export function matchKeyboardEvent(
+  event: KeyboardEvent,
+  hotkey: Hotkey | ParsedHotkey,
+  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),
+): KeyboardEventMatch {
+  const parsed =
+    typeof hotkey === 'string' ? parseHotkey(hotkey, platform) : hotkey
+  const normalized = normalizeKeyboardEvent(event, platform)
+  const noMatch: KeyboardEventMatch = { matched: false, score: 0 }
+
+  if (
+    normalized.isComposing &&
+    (parsed.code !== undefined || isPrintableKey(parsed.key))
+  )
+    return noMatch
+  if (normalized.altGraph && (parsed.ctrl || parsed.alt)) return noMatch
+
+  if (parsed.code !== undefined) {
+    if (!modifiersMatch(normalized, parsed, false)) return noMatch
+    return normalized.code === parsed.code ? matched('code', 3) : noMatch
+  }
+
+  const direct = keysEqual(normalized.key, parsed.key)
+  const implicitShift =
+    direct &&
+    isPrintableKey(normalized.key) &&
+    !/^\p{Letter}$/u.test(normalized.key) &&
+    !parsed.shift
+
+  if (direct && modifiersMatch(normalized, parsed, implicitShift)) {
+    return matched('key', implicitShift ? 2 : 3)
+  }
+
+  // ASCII alphabetic output is authoritative for Dvorak/Colemak/AZERTY.
+  // Native Latin letters are also authoritative on Key* positions; Alt is the
+  // exception because macOS Option commonly transforms a shortcut's glyph.
+  if (
+    isAsciiLetter(normalized.key) ||
+    (isLatinLetter(normalized.key) &&
+      normalized.code.startsWith('Key') &&
+      !normalized.alt)
+  ) {
+    return noMatch
+  }
+
+  if (!modifiersMatch(normalized, parsed, false)) return noMatch
+  const fallbackKey = codeToLogicalKey(normalized.code)
+  return fallbackKey !== undefined && keysEqual(fallbackKey, parsed.key)
+    ? matched('fallback', 1)
+    : noMatch
+
+  // Preserve the triggering code so keyup can reset a shortcut even if its character changes.
+  function matched(
+    source: 'key' | 'code' | 'fallback',
+    score: 1 | 2 | 3,
+  ): KeyboardEventMatch {
+    return {
+      matched: true,
+      score,
+      source,
+      identity: { key: normalized.key, code: normalized.code },
+    }
+  }
+}
+
+/** Compares modifiers, excluding synthetic AltGr flags and optionally allowing Shift used to type a glyph. */
+function modifiersMatch(
+  event: ReturnType<typeof normalizeKeyboardEvent>,
+  parsed: ParsedHotkey,
+  allowImplicitShift: boolean,
+): boolean {
+  const ctrl = event.altGraph ? false : event.ctrl
+  const alt = event.altGraph ? false : event.alt
+  if (
+    ctrl !== parsed.ctrl ||
+    alt !== parsed.alt ||
+    event.meta !== parsed.meta
+  ) {
+    return false
+  }
+  return event.shift === parsed.shift || (allowImplicitShift && event.shift)
+}

package/src/_named-keys.ts

@@ -0,0 +1,62 @@
+/** Names defined for both KeyboardEvent.key and KeyboardEvent.code, beyond the basic key groups. */
+export const SHARED_NAMED_KEYS = [
+  'CapsLock',
+  'ContextMenu',
+  'Convert',
+  'KanaMode',
+  'NonConvert',
+  'Help',
+  'Insert',
+  'NumLock',
+  'Fn',
+  'FnLock',
+  'PrintScreen',
+  'ScrollLock',
+  'Pause',
+  'BrowserBack',
+  'BrowserFavorites',
+  'BrowserForward',
+  'BrowserHome',
+  'BrowserRefresh',
+  'BrowserSearch',
+  'BrowserStop',
+  'Eject',
+  'LaunchMail',
+  'MediaPlayPause',
+  'MediaStop',
+  'MediaTrackNext',
+  'MediaTrackPrevious',
+  'Power',
+  'AudioVolumeDown',
+  'AudioVolumeMute',
+  'AudioVolumeUp',
+  'WakeUp',
+  'Hyper',
+  'Super',
+  'Again',
+  'Copy',
+  'Cut',
+  'Find',
+  'Open',
+  'Paste',
+  'Props',
+  'Select',
+  'Undo',
+  'Hiragana',
+  'Katakana',
+] as const
+
+/** Logical counterparts whose physical positions use different names (for example Sleep and Lang1). */
+export const LOGICAL_ONLY_NAMED_KEYS = [
+  'Clear',
+  'Cancel',
+  'Standby',
+  'LaunchApplication1',
+  'LaunchApplication2',
+  'LaunchMediaPlayer',
+  'HangulMode',
+  'HanjaMode',
+  'Zenkaku',
+  'Hankaku',
+  'ZenkakuHankaku',
+] as const

package/src/_recorder-chord.ts

@@ -0,0 +1,76 @@
+import { normalizeKeyName } from './constants'
+import { normalizeKeyboardEvent } from './_keyboard-event'
+import {
+  isModifierKey,
+  normalizeHotkeyFromParsed,
+  parseKeyboardEvent,
+} from './parse'
+import type {
+  RecorderKeyMode,
+  RecorderOptions,
+  RecorderRejection,
+} from './recorder-options'
+import type { Hotkey } from './hotkey.types'
+
+/**
+ * Converts a keydown to a replayable chord, preserving physical codes by default.
+ * Returns null for composition, modifier-only input, or unusable physical input.
+ * Key mode retains the produced character; neither mode guesses layout letters.
+ */
+export function hotkeyChordFromKeydown(
+  event: KeyboardEvent,
+  platform: 'mac' | 'windows' | 'linux',
+  recordBy: RecorderKeyMode = 'code',
+): Hotkey | null {
+  const normalized = normalizeKeyboardEvent(event, platform)
+  if (
+    normalized.isComposing ||
+    isModifierKey(normalizeKeyName(event.key)) ||
+    event.key === 'AltGraph'
+  )
+    return null
+  if (
+    recordBy === 'code' &&
+    (!/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) ||
+      event.code === 'Unidentified' ||
+      normalized.altGraph)
+  )
+    return null
+  const parsed = parseKeyboardEvent(event, platform)
+  if (recordBy === 'code') {
+    // Remove logical identity rather than placing a physical code in the key field.
+    const { key: _key, code: _code, ...modifiers } = parsed
+    return normalizeHotkeyFromParsed(
+      { ...modifiers, code: event.code },
+      platform,
+    )
+  }
+  return parsed.key ? normalizeHotkeyFromParsed(parsed, platform) : null
+}
+
+/**
+ * Explains why a physical chord cannot be recorded before syntax/policy checks.
+ * Logical mode deliberately accepts produced characters instead of requiring a code.
+ */
+export function chordRejection(
+  event: KeyboardEvent,
+  options: RecorderOptions,
+): RecorderRejection | undefined {
+  if (options.recordBy === 'key') return undefined
+  // AltGr is character entry, often reported as synthetic Ctrl+Alt; macOS Option is handled separately.
+  if (normalizeKeyboardEvent(event, options.platform).altGraph)
+    return {
+      reason: 'alt-graph',
+      message:
+        'AltGraph character entry cannot be recorded as a physical shortcut. Use key mode for characters.',
+    }
+  if (
+    !/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) ||
+    event.code === 'Unidentified'
+  )
+    return {
+      reason: 'missing-code',
+      message: 'This event has no usable physical key code.',
+    }
+  return undefined
+}

package/src/_recording-guard.ts

@@ -0,0 +1,63 @@
+import { MODIFIER_KEYS, normalizeKeyName } from './constants'
+
+// Shared only by recorders and dispatchers. Does not own bindings or preferences.
+// Multiple recorder instances may be active; dispatch resumes after the last one ends.
+const sessions = new Set<object>()
+// Remember consumed event objects through the remainder of their DOM dispatch.
+const captured = new WeakSet<KeyboardEvent>()
+// Captured physical identities stay blocked through repeats and their eventual keyup.
+const pending = new Map<string, string>()
+let listening = false
+// Prefer the stable physical identity when modifier release changes event.key.
+const identity = (event: KeyboardEvent) => event.code || `key:${event.key}`
+
+/** Consumes recorded key releases and removes guards for completed chords. */
+function release(event: KeyboardEvent): void {
+  if (pending.delete(identity(event))) captured.add(event)
+  // macOS can swallow the main key's keyup while Command is held.
+  // Releasing a modifier ends that chord, as in KeyStateTracker.
+  if (MODIFIER_KEYS.has(normalizeKeyName(event.key))) {
+    for (const [id, key] of pending) {
+      if (!MODIFIER_KEYS.has(key)) pending.delete(id)
+    }
+  }
+  cleanup()
+}
+/** Clears pending releases when focus loss prevents the browser from delivering them. */
+function blur(): void {
+  pending.clear()
+  cleanup()
+}
+/** Detaches shared listeners once neither active sessions nor pending releases need them. */
+function cleanup(): void {
+  if (listening && sessions.size === 0 && pending.size === 0) {
+    document.removeEventListener('keyup', release, true)
+    window.removeEventListener('blur', blur)
+    listening = false
+  }
+}
+/** Pauses application shortcut dispatch and starts tracking releases for this recorder. */
+export function beginRecording(owner: object): void {
+  sessions.add(owner)
+  if (!listening && typeof document !== 'undefined') {
+    document.addEventListener('keyup', release, true)
+    window.addEventListener('blur', blur)
+    listening = true
+  }
+}
+/** Ends a session while retaining guards for keys still held after commit or cancellation. */
+export function endRecording(owner: object): void {
+  sessions.delete(owner)
+  cleanup()
+}
+/** Marks a consumed keydown and guards subsequent repeats and its release. */
+export function captureRecordingEvent(event: KeyboardEvent): void {
+  captured.add(event)
+  pending.set(identity(event), normalizeKeyName(event.key))
+}
+/** Whether managers should suppress callbacks for this recording session or captured chord. */
+export function isRecordingEvent(event: KeyboardEvent): boolean {
+  return (
+    sessions.size > 0 || captured.has(event) || pending.has(identity(event))
+  )
+}

package/src/_registration.ts

@@ -0,0 +1,79 @@
+import type { ConflictBehavior, ParsedHotkey } from './hotkey.types'
+
+/**
+ * Default options for hotkey/sequence registration.
+ * Omitted: platform, target (resolved at registration), requireReset (HotkeyManager only).
+ */
+export const defaultHotkeyOptions = {
+  preventDefault: true,
+  stopPropagation: true,
+  eventType: 'keydown' as const,
+  enabled: true,
+  ignoreInputs: true,
+  conflictBehavior: 'warn' as ConflictBehavior,
+}
+
+/**
+ * Computes the default ignoreInputs value based on the hotkey.
+ * Ctrl/Meta shortcuts and Escape fire in inputs; single keys and Shift/Alt combos are ignored.
+ */
+export function getDefaultIgnoreInputs(parsedHotkey: ParsedHotkey): boolean {
+  if (parsedHotkey.ctrl || parsedHotkey.meta) return false // Mod+S, Ctrl+C, etc.
+  if (parsedHotkey.key === 'Escape' || parsedHotkey.code === 'Escape')
+    return false // Close modal, etc.
+  return true // Single keys, Shift+key, Alt+key
+}
+
+/**
+ * Handles conflicts between registrations based on conflict behavior.
+ *
+ * @param conflictingId - The ID of the conflicting registration
+ * @param keyDisplay - Display string for the conflicting key/sequence (for error messages)
+ * @param conflictBehavior - How to handle the conflict
+ * @param unregister - Function to unregister by ID
+ */
+export function handleConflict(
+  conflictingId: string,
+  keyDisplay: string,
+  conflictBehavior: ConflictBehavior,
+  unregister: (id: string) => void,
+): void {
+  if (conflictBehavior === 'allow') {
+    return
+  }
+
+  if (conflictBehavior === 'warn') {
+    console.warn(
+      `'${keyDisplay}' is already registered. Multiple handlers will be triggered. ` +
+        `Use conflictBehavior: 'replace' to replace the existing handler, ` +
+        `or conflictBehavior: 'allow' to suppress this warning.`,
+    )
+    return
+  }
+
+  if (conflictBehavior === 'error') {
+    throw new Error(
+      `'${keyDisplay}' is already registered. ` +
+        `Use conflictBehavior: 'replace' to replace the existing handler, ` +
+        `or conflictBehavior: 'allow' to allow multiple registrations.`,
+    )
+  }
+
+  // At this point, conflictBehavior must be 'replace'
+  unregister(conflictingId)
+}
+
+/** Compare updates without publishing unchanged options, including fresh metadata objects. */
+export function optionsEqual(left: object, right: object): boolean {
+  const a = left as Record<string, unknown>
+  const b = right as Record<string, unknown>
+  const keys = Object.keys(a)
+  return (
+    keys.length === Object.keys(b).length &&
+    keys.every((key) =>
+      key === 'meta' && a[key] && b[key]
+        ? optionsEqual(a[key] as object, b[key] as object)
+        : Object.is(a[key], b[key]),
+    )
+  )
+}

package/src/conflicts.ts

@@ -0,0 +1,125 @@
+import { detectPlatform } from './platform'
+import { parseRegisterableHotkey } from './parse'
+import { keysEqual } from './_keyboard-event'
+import { matchesKeyboardEvent } from './match'
+import { getHotkeyManager, toHotkeyRegistrationView } from './hotkey-manager'
+import { getSequenceManager } from './sequence-manager'
+import type { HotkeyRegistrationView } from './hotkey-manager'
+import type { SequenceRegistrationView } from './sequence-manager'
+import type { RegisterableHotkey } from './hotkey.types'
+
+export type HotkeyConflict =
+  | { type: 'hotkey'; registration: HotkeyRegistrationView }
+  | { type: 'sequence'; registration: SequenceRegistrationView }
+
+export interface HotkeyConflictOptions {
+  /** Intended registration target. Defaults to document; disjoint targets are excluded. */
+  target?: HTMLElement | Document | Window
+  /** Check all targets instead of overlapping targets. Default: overlapping. */
+  scope?: 'overlapping' | 'all'
+  /** Intended event type. Default: keydown. */
+  eventType?: 'keydown' | 'keyup'
+  /** Include disabled registrations. Default: false. */
+  includeDisabled?: boolean
+  /** IDs of registrations being edited. */
+  excludeIds?: ReadonlyArray<string>
+  /** Additional app-specific exclusions, such as all instances of one action. */
+  exclude?: (
+    registration: HotkeyRegistrationView | SequenceRegistrationView,
+  ) => boolean
+  /** Platform used to resolve Mod in the candidate. Registrations retain their own platform. */
+  platform?: 'mac' | 'windows' | 'linux'
+  /** Source events allow detecting physical/logical overlap on the recorded layout. */
+  events?: ReadonlyArray<KeyboardEvent>
+}
+
+/** Whether two targets share a document and one contains the other (or is its window). */
+function targetsOverlap(
+  a: HTMLElement | Document | Window,
+  b: HTMLElement | Document | Window,
+): boolean {
+  if (a === b) return true
+  // Resolve the owning document without relying on cross-frame instanceof checks.
+  const documentOf = (target: typeof a): Document | null => {
+    if ('document' in target) return target.document
+    if (target.nodeType === 9) return target as Document
+    return target.ownerDocument
+  }
+  if (documentOf(a) !== documentOf(b)) return false
+  if (!('contains' in a) || !('contains' in b)) return true
+  return a.contains(b as Node) || b.contains(a as Node)
+}
+
+/**
+ * Find equivalent bindings and sequence-prefix conflicts in the live registry.
+ * With source events, also checks observed logical/physical overlap. Does not
+ * discover unmounted handlers, external listeners, or other keyboard layouts.
+ */
+export function findHotkeyConflicts(
+  candidate: RegisterableHotkey | ReadonlyArray<RegisterableHotkey>,
+  options: HotkeyConflictOptions = {},
+): Array<HotkeyConflict> {
+  const steps: ReadonlyArray<RegisterableHotkey> = Array.isArray(candidate)
+    ? candidate
+    : [candidate as RegisterableHotkey]
+  if (steps.length === 0) return []
+  const platform = options.platform ?? detectPlatform()
+  const parsed = steps.map((step) => parseRegisterableHotkey(step, platform))
+  const target =
+    options.target ?? (typeof document === 'undefined' ? undefined : document)
+  const conflicts: Array<HotkeyConflict> = []
+  // Apply scope policy before comparing equivalent bindings or observed event overlap.
+  const matches = (
+    registration: HotkeyRegistrationView | SequenceRegistrationView,
+    bindings: ReadonlyArray<RegisterableHotkey>,
+  ) => {
+    if (
+      (!options.includeDisabled && registration.options.enabled === false) ||
+      (registration.options.eventType ?? 'keydown') !==
+        (options.eventType ?? 'keydown') ||
+      options.excludeIds?.includes(registration.id) ||
+      options.exclude?.(registration) ||
+      (options.scope !== 'all' &&
+        target &&
+        !targetsOverlap(target, registration.target))
+    )
+      return false
+    // Compare only the common prefix: a shorter sequence can collide with a longer one.
+    return parsed
+      .slice(0, Math.min(parsed.length, bindings.length))
+      .every((a, index) => {
+        const b = parseRegisterableHotkey(
+          bindings[index]!,
+          registration.options.platform,
+        )
+        const same =
+          a.ctrl === b.ctrl &&
+          a.alt === b.alt &&
+          a.shift === b.shift &&
+          a.meta === b.meta &&
+          (a.code !== undefined || b.code !== undefined
+            ? a.code === b.code
+            : keysEqual(a.key, b.key))
+        // A source event can establish code/key overlap without guessing its layout.
+        const event = options.events?.[index]
+        return (
+          same ||
+          (event !== undefined &&
+            matchesKeyboardEvent(event, a, platform) &&
+            matchesKeyboardEvent(event, b, registration.options.platform))
+        )
+      })
+  }
+  for (const registration of getHotkeyManager().registrations.state.values()) {
+    if (matches(registration, [registration.hotkey]))
+      conflicts.push({
+        type: 'hotkey',
+        registration: toHotkeyRegistrationView(registration),
+      })
+  }
+  for (const registration of getSequenceManager().registrations.state.values()) {
+    if (matches(registration, registration.sequence))
+      conflicts.push({ type: 'sequence', registration })
+  }
+  return conflicts
+}