@tanstack/hotkeys 0.8.0 → 0.9.0

package/dist/conflicts.js

@@ -0,0 +1,55 @@
+import { detectPlatform } from "./platform.js";
+import { keysEqual } from "./_keyboard-event.js";
+import { parseRegisterableHotkey } from "./parse.js";
+import { matchesKeyboardEvent } from "./match.js";
+import { getHotkeyManager, toHotkeyRegistrationView } from "./hotkey-manager.js";
+import { getSequenceManager } from "./sequence-manager.js";
+
+//#region src/conflicts.ts
+/** Whether two targets share a document and one contains the other (or is its window). */
+function targetsOverlap(a, b) {
+	if (a === b) return true;
+	const documentOf = (target) => {
+		if ("document" in target) return target.document;
+		if (target.nodeType === 9) return target;
+		return target.ownerDocument;
+	};
+	if (documentOf(a) !== documentOf(b)) return false;
+	if (!("contains" in a) || !("contains" in b)) return true;
+	return a.contains(b) || b.contains(a);
+}
+/**
+* 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.
+*/
+function findHotkeyConflicts(candidate, options = {}) {
+	const steps = Array.isArray(candidate) ? candidate : [candidate];
+	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" ? void 0 : document);
+	const conflicts = [];
+	const matches = (registration, bindings) => {
+		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;
+		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 !== void 0 || b.code !== void 0 ? a.code === b.code : keysEqual(a.key, b.key));
+			const event = options.events?.[index];
+			return same || event !== void 0 && 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;
+}
+
+//#endregion
+export { findHotkeyConflicts };
+//# sourceMappingURL=conflicts.js.map

package/dist/conflicts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflicts.js","names":[],"sources":["../src/conflicts.ts"],"sourcesContent":["import { detectPlatform } from './platform'\nimport { parseRegisterableHotkey } from './parse'\nimport { keysEqual } from './_keyboard-event'\nimport { matchesKeyboardEvent } from './match'\nimport { getHotkeyManager, toHotkeyRegistrationView } from './hotkey-manager'\nimport { getSequenceManager } from './sequence-manager'\nimport type { HotkeyRegistrationView } from './hotkey-manager'\nimport type { SequenceRegistrationView } from './sequence-manager'\nimport type { RegisterableHotkey } from './hotkey.types'\n\nexport type HotkeyConflict =\n  | { type: 'hotkey'; registration: HotkeyRegistrationView }\n  | { type: 'sequence'; registration: SequenceRegistrationView }\n\nexport interface HotkeyConflictOptions {\n  /** Intended registration target. Defaults to document; disjoint targets are excluded. */\n  target?: HTMLElement | Document | Window\n  /** Check all targets instead of overlapping targets. Default: overlapping. */\n  scope?: 'overlapping' | 'all'\n  /** Intended event type. Default: keydown. */\n  eventType?: 'keydown' | 'keyup'\n  /** Include disabled registrations. Default: false. */\n  includeDisabled?: boolean\n  /** IDs of registrations being edited. */\n  excludeIds?: ReadonlyArray<string>\n  /** Additional app-specific exclusions, such as all instances of one action. */\n  exclude?: (\n    registration: HotkeyRegistrationView | SequenceRegistrationView,\n  ) => boolean\n  /** Platform used to resolve Mod in the candidate. Registrations retain their own platform. */\n  platform?: 'mac' | 'windows' | 'linux'\n  /** Source events allow detecting physical/logical overlap on the recorded layout. */\n  events?: ReadonlyArray<KeyboardEvent>\n}\n\n/** Whether two targets share a document and one contains the other (or is its window). */\nfunction targetsOverlap(\n  a: HTMLElement | Document | Window,\n  b: HTMLElement | Document | Window,\n): boolean {\n  if (a === b) return true\n  // Resolve the owning document without relying on cross-frame instanceof checks.\n  const documentOf = (target: typeof a): Document | null => {\n    if ('document' in target) return target.document\n    if (target.nodeType === 9) return target as Document\n    return target.ownerDocument\n  }\n  if (documentOf(a) !== documentOf(b)) return false\n  if (!('contains' in a) || !('contains' in b)) return true\n  return a.contains(b as Node) || b.contains(a as Node)\n}\n\n/**\n * Find equivalent bindings and sequence-prefix conflicts in the live registry.\n * With source events, also checks observed logical/physical overlap. Does not\n * discover unmounted handlers, external listeners, or other keyboard layouts.\n */\nexport function findHotkeyConflicts(\n  candidate: RegisterableHotkey | ReadonlyArray<RegisterableHotkey>,\n  options: HotkeyConflictOptions = {},\n): Array<HotkeyConflict> {\n  const steps: ReadonlyArray<RegisterableHotkey> = Array.isArray(candidate)\n    ? candidate\n    : [candidate as RegisterableHotkey]\n  if (steps.length === 0) return []\n  const platform = options.platform ?? detectPlatform()\n  const parsed = steps.map((step) => parseRegisterableHotkey(step, platform))\n  const target =\n    options.target ?? (typeof document === 'undefined' ? undefined : document)\n  const conflicts: Array<HotkeyConflict> = []\n  // Apply scope policy before comparing equivalent bindings or observed event overlap.\n  const matches = (\n    registration: HotkeyRegistrationView | SequenceRegistrationView,\n    bindings: ReadonlyArray<RegisterableHotkey>,\n  ) => {\n    if (\n      (!options.includeDisabled && registration.options.enabled === false) ||\n      (registration.options.eventType ?? 'keydown') !==\n        (options.eventType ?? 'keydown') ||\n      options.excludeIds?.includes(registration.id) ||\n      options.exclude?.(registration) ||\n      (options.scope !== 'all' &&\n        target &&\n        !targetsOverlap(target, registration.target))\n    )\n      return false\n    // Compare only the common prefix: a shorter sequence can collide with a longer one.\n    return parsed\n      .slice(0, Math.min(parsed.length, bindings.length))\n      .every((a, index) => {\n        const b = parseRegisterableHotkey(\n          bindings[index]!,\n          registration.options.platform,\n        )\n        const same =\n          a.ctrl === b.ctrl &&\n          a.alt === b.alt &&\n          a.shift === b.shift &&\n          a.meta === b.meta &&\n          (a.code !== undefined || b.code !== undefined\n            ? a.code === b.code\n            : keysEqual(a.key, b.key))\n        // A source event can establish code/key overlap without guessing its layout.\n        const event = options.events?.[index]\n        return (\n          same ||\n          (event !== undefined &&\n            matchesKeyboardEvent(event, a, platform) &&\n            matchesKeyboardEvent(event, b, registration.options.platform))\n        )\n      })\n  }\n  for (const registration of getHotkeyManager().registrations.state.values()) {\n    if (matches(registration, [registration.hotkey]))\n      conflicts.push({\n        type: 'hotkey',\n        registration: toHotkeyRegistrationView(registration),\n      })\n  }\n  for (const registration of getSequenceManager().registrations.state.values()) {\n    if (matches(registration, registration.sequence))\n      conflicts.push({ type: 'sequence', registration })\n  }\n  return conflicts\n}\n"],"mappings":";;;;;;;;;AAoCA,SAAS,eACP,GACA,GACS;AACT,KAAI,MAAM,EAAG,QAAO;CAEpB,MAAM,cAAc,WAAsC;AACxD,MAAI,cAAc,OAAQ,QAAO,OAAO;AACxC,MAAI,OAAO,aAAa,EAAG,QAAO;AAClC,SAAO,OAAO;;AAEhB,KAAI,WAAW,EAAE,KAAK,WAAW,EAAE,CAAE,QAAO;AAC5C,KAAI,EAAE,cAAc,MAAM,EAAE,cAAc,GAAI,QAAO;AACrD,QAAO,EAAE,SAAS,EAAU,IAAI,EAAE,SAAS,EAAU;;;;;;;AAQvD,SAAgB,oBACd,WACA,UAAiC,EAAE,EACZ;CACvB,MAAM,QAA2C,MAAM,QAAQ,UAAU,GACrE,YACA,CAAC,UAAgC;AACrC,KAAI,MAAM,WAAW,EAAG,QAAO,EAAE;CACjC,MAAM,WAAW,QAAQ,YAAY,gBAAgB;CACrD,MAAM,SAAS,MAAM,KAAK,SAAS,wBAAwB,MAAM,SAAS,CAAC;CAC3E,MAAM,SACJ,QAAQ,WAAW,OAAO,aAAa,cAAc,SAAY;CACnE,MAAM,YAAmC,EAAE;CAE3C,MAAM,WACJ,cACA,aACG;AACH,MACG,CAAC,QAAQ,mBAAmB,aAAa,QAAQ,YAAY,UAC7D,aAAa,QAAQ,aAAa,gBAChC,QAAQ,aAAa,cACxB,QAAQ,YAAY,SAAS,aAAa,GAAG,IAC7C,QAAQ,UAAU,aAAa,IAC9B,QAAQ,UAAU,SACjB,UACA,CAAC,eAAe,QAAQ,aAAa,OAAO,CAE9C,QAAO;AAET,SAAO,OACJ,MAAM,GAAG,KAAK,IAAI,OAAO,QAAQ,SAAS,OAAO,CAAC,CAClD,OAAO,GAAG,UAAU;GACnB,MAAM,IAAI,wBACR,SAAS,QACT,aAAa,QAAQ,SACtB;GACD,MAAM,OACJ,EAAE,SAAS,EAAE,QACb,EAAE,QAAQ,EAAE,OACZ,EAAE,UAAU,EAAE,SACd,EAAE,SAAS,EAAE,SACZ,EAAE,SAAS,UAAa,EAAE,SAAS,SAChC,EAAE,SAAS,EAAE,OACb,UAAU,EAAE,KAAK,EAAE,IAAI;GAE7B,MAAM,QAAQ,QAAQ,SAAS;AAC/B,UACE,QACC,UAAU,UACT,qBAAqB,OAAO,GAAG,SAAS,IACxC,qBAAqB,OAAO,GAAG,aAAa,QAAQ,SAAS;IAEjE;;AAEN,MAAK,MAAM,gBAAgB,kBAAkB,CAAC,cAAc,MAAM,QAAQ,CACxE,KAAI,QAAQ,cAAc,CAAC,aAAa,OAAO,CAAC,CAC9C,WAAU,KAAK;EACb,MAAM;EACN,cAAc,yBAAyB,aAAa;EACrD,CAAC;AAEN,MAAK,MAAM,gBAAgB,oBAAoB,CAAC,cAAc,MAAM,QAAQ,CAC1E,KAAI,QAAQ,cAAc,aAAa,SAAS,CAC9C,WAAU,KAAK;EAAE,MAAM;EAAY;EAAc,CAAC;AAEtD,QAAO"}

package/dist/constants.cjs

@@ -1,29 +1,7 @@
+const require__named_keys = require('./_named-keys.cjs');
 
 //#region src/constants.ts
 /**
-* Detects the current platform based on browser navigator properties.
-*
-* Used internally to resolve platform-adaptive modifiers like 'Mod' (Command on Mac,
-* Control elsewhere) and for platform-specific hotkey formatting.
-*
-* @returns The detected platform: 'mac', 'windows', or 'linux'
-* @remarks Defaults to 'linux' in SSR environments where navigator is undefined
-*
-* @example
-* ```ts
-* const platform = detectPlatform() // 'mac' | 'windows' | 'linux'
-* const modifier = resolveModifier('Mod', platform) // 'Meta' on Mac, 'Control' elsewhere
-* ```
-*/
-function detectPlatform() {
-	if (typeof navigator === "undefined") return "linux";
-	const platform = navigator.platform?.toLowerCase() ?? "";
-	const userAgent = navigator.userAgent?.toLowerCase() ?? "";
-	if (platform.includes("mac") || userAgent.includes("mac")) return "mac";
-	if (platform.includes("win") || userAgent.includes("win")) return "windows";
-	return "linux";
-}
-/**
 * Canonical order for modifiers in normalized hotkey strings.
 *
 * Defines the standard order in which modifiers should appear when formatting
@@ -97,31 +75,6 @@ const MODIFIER_ALIASES = {
 	mod: "Mod"
 };
 /**
-* Resolves the platform-adaptive 'Mod' modifier to the appropriate canonical modifier.
-*
-* The 'Mod' token represents the "primary modifier" on each platform:
-* - macOS: 'Meta' (Command key ⌘)
-* - Windows/Linux: 'Control' (Ctrl key)
-*
-* This enables cross-platform hotkey definitions like 'Mod+S' that automatically
-* map to Command+S on Mac and Ctrl+S on Windows/Linux.
-*
-* @param modifier - The modifier to resolve. If 'Mod', resolves based on platform.
-* @param platform - The target platform. Defaults to auto-detection.
-* @returns The canonical modifier name ('Control', 'Shift', 'Alt', or 'Meta')
-*
-* @example
-* ```ts
-* resolveModifier('Mod', 'mac') // 'Meta'
-* resolveModifier('Mod', 'windows') // 'Control'
-* resolveModifier('Control', 'mac') // 'Control' (unchanged)
-* ```
-*/
-function resolveModifier(modifier, platform = detectPlatform()) {
-	if (modifier === "Mod") return platform === "mac" ? "Meta" : "Control";
-	return modifier;
-}
-/**
 * Set of all valid letter keys (A-Z).
 *
 * Used for validation and type checking. Letter keys are matched case-insensitively
@@ -175,7 +128,7 @@ const NUMBER_KEYS = new Set([
 	"9"
 ]);
 /**
-* Set of all valid function keys (F1-F12).
+* Set of all valid function keys (F1-F24).
 *
 * Function keys are commonly used for system shortcuts (e.g., F12 for DevTools,
 * Alt+F4 to close windows) and application-specific commands.
@@ -192,7 +145,19 @@ const FUNCTION_KEYS = new Set([
 	"F9",
 	"F10",
 	"F11",
-	"F12"
+	"F12",
+	"F13",
+	"F14",
+	"F15",
+	"F16",
+	"F17",
+	"F18",
+	"F19",
+	"F20",
+	"F21",
+	"F22",
+	"F23",
+	"F24"
 ]);
 /**
 * Set of all valid navigation keys for cursor movement and document navigation.
@@ -248,7 +213,29 @@ const PUNCTUATION_KEYS = new Set([
 	",",
 	".",
 	";",
-	"`"
+	"`",
+	"'",
+	"+",
+	"?",
+	"!",
+	"@",
+	"#",
+	"$",
+	"%",
+	"^",
+	"&",
+	"*",
+	"(",
+	")",
+	"_",
+	"{",
+	"}",
+	"|",
+	":",
+	"\"",
+	"<",
+	">",
+	"~"
 ]);
 /**
 * Maps `KeyboardEvent.code` values for punctuation keys to their canonical characters.
@@ -268,6 +255,7 @@ const PUNCTUATION_CODE_MAP = {
 	Equal: "=",
 	Minus: "-",
 	Period: ".",
+	Quote: "'",
 	Semicolon: ";",
 	Slash: "/"
 };
@@ -291,8 +279,11 @@ const ALL_KEYS = new Set([
 	...FUNCTION_KEYS,
 	...NAVIGATION_KEYS,
 	...EDITING_KEYS,
-	...PUNCTUATION_KEYS
+	...PUNCTUATION_KEYS,
+	...require__named_keys.SHARED_NAMED_KEYS,
+	...require__named_keys.LOGICAL_ONLY_NAMED_KEYS
 ]);
+const CANONICAL_KEY_NAMES = new Map(Array.from(ALL_KEYS, (key) => [key.toLowerCase(), key]));
 /**
 * Maps key name aliases to their canonical form.
 *
@@ -313,6 +304,8 @@ const ALL_KEYS = new Set([
 * ```
 */
 const KEY_ALIASES = {
+	Plus: "+",
+	plus: "+",
 	Esc: "Escape",
 	esc: "Escape",
 	escape: "Escape",
@@ -397,128 +390,14 @@ function normalizeKeyName(key) {
 		const upper = key.toUpperCase();
 		return upper.length === 1 ? upper : key;
 	}
-	const upperKey = key.toUpperCase();
-	if (/^F([1-9]|1[0-2])$/.test(upperKey)) return upperKey;
-	return key;
+	return CANONICAL_KEY_NAMES.get(key.toLowerCase()) ?? key;
 }
-/**
-* Modifier key symbols for macOS display.
-*
-* Used by formatting functions to display hotkeys with macOS-style symbols
-* (e.g., ⌘ for Command, ⌃ for Control) instead of text labels. This provides
-* a native macOS look and feel in hotkey displays.
-*
-* @example
-* ```ts
-* MAC_MODIFIER_SYMBOLS['Meta'] // '⌘'
-* MAC_MODIFIER_SYMBOLS['Control'] // '⌃'
-* MAC_MODIFIER_SYMBOLS['Alt'] // '⌥'
-* MAC_MODIFIER_SYMBOLS['Shift'] // '⇧'
-* ```
-*/
-const MAC_MODIFIER_SYMBOLS = {
-	Control: "⌃",
-	Alt: "⌥",
-	Shift: "⇧",
-	Meta: "⌘",
-	Mod: "⌘"
-};
-/**
-* Modifier key labels for macOS display.
-*
-* Used by formatting functions to display hotkeys with macOS-style text labels
-* (e.g., 'Control' for Control, 'Option' for Alt, 'Cmd' for Meta) instead of symbols.
-* This provides a familiar macOS look and feel in hotkey displays.
-*
-* @example
-* ```ts
-* MAC_MODIFIER_LABELS['Control'] // 'control'
-* MAC_MODIFIER_LABELS['Alt'] // 'option'
-* MAC_MODIFIER_LABELS['Shift'] // 'shift'
-* MAC_MODIFIER_LABELS['Meta'] // 'cmd'
-* ```
-*/
-const MAC_MODIFIER_LABELS = {
-	Control: "Control",
-	Alt: "Option",
-	Shift: "Shift",
-	Meta: "Cmd",
-	Mod: "Cmd"
-};
-/**
-* Modifier key labels for Windows/Linux display.
-*
-* Used by formatting functions to display hotkeys with standard text labels
-* (e.g., 'Ctrl' for Control, 'Win' for Meta/Windows key) instead of symbols.
-* This provides a familiar Windows/Linux look and feel in hotkey displays.
-*
-* @example
-* ```ts
-* STANDARD_MODIFIER_LABELS['Control'] // 'Ctrl'
-* STANDARD_MODIFIER_LABELS['Meta'] // 'Win'
-* STANDARD_MODIFIER_LABELS['Alt'] // 'Alt'
-* STANDARD_MODIFIER_LABELS['Shift'] // 'Shift'
-* ```
-*/
-const WINDOWS_MODIFIER_LABELS = {
-	Control: "Ctrl",
-	Alt: "Alt",
-	Shift: "Shift",
-	Meta: "Win",
-	Mod: "Ctrl"
-};
-const LINUX_MODIFIER_LABELS = {
-	...WINDOWS_MODIFIER_LABELS,
-	Meta: "Super"
-};
-const PUNCTUATION_KEY_DISPLAY_LABELS = {
-	"`": "Backquote",
-	"\\": "Backslash",
-	"[": "Left Bracket",
-	"]": "Right Bracket",
-	",": "Comma",
-	"=": "Equal",
-	"-": "Minus",
-	".": "Period",
-	";": "Semicolon"
-};
-/**
-* Special key symbols for display formatting.
-*
-* Maps certain keys to their visual symbols for better readability in hotkey displays.
-* Used by formatting functions to show symbols like ↑ for ArrowUp or ↵ for Enter
-* instead of text labels.
-*
-* @example
-* ```ts
-* KEY_DISPLAY_SYMBOLS['ArrowUp'] // '↑'
-* KEY_DISPLAY_SYMBOLS['Enter'] // '↵'
-* KEY_DISPLAY_SYMBOLS['Escape'] // 'Esc'
-* KEY_DISPLAY_SYMBOLS['Space'] // '␣'
-* ```
-*/
-const KEY_DISPLAY_SYMBOLS = {
-	ArrowUp: "↑",
-	ArrowDown: "↓",
-	ArrowLeft: "←",
-	ArrowRight: "→",
-	Enter: "↵",
-	Escape: "Esc",
-	Backspace: "⌫",
-	Delete: "⌦",
-	Tab: "⇥",
-	Space: "␣"
-};
 
 //#endregion
 exports.ALL_KEYS = ALL_KEYS;
 exports.EDITING_KEYS = EDITING_KEYS;
 exports.FUNCTION_KEYS = FUNCTION_KEYS;
-exports.KEY_DISPLAY_SYMBOLS = KEY_DISPLAY_SYMBOLS;
 exports.LETTER_KEYS = LETTER_KEYS;
-exports.LINUX_MODIFIER_LABELS = LINUX_MODIFIER_LABELS;
-exports.MAC_MODIFIER_LABELS = MAC_MODIFIER_LABELS;
-exports.MAC_MODIFIER_SYMBOLS = MAC_MODIFIER_SYMBOLS;
 exports.MODIFIER_ALIASES = MODIFIER_ALIASES;
 exports.MODIFIER_KEYS = MODIFIER_KEYS;
 exports.MODIFIER_ORDER = MODIFIER_ORDER;
@@ -526,10 +405,6 @@ exports.NAVIGATION_KEYS = NAVIGATION_KEYS;
 exports.NUMBER_KEYS = NUMBER_KEYS;
 exports.PUNCTUATION_CODE_MAP = PUNCTUATION_CODE_MAP;
 exports.PUNCTUATION_KEYS = PUNCTUATION_KEYS;
-exports.PUNCTUATION_KEY_DISPLAY_LABELS = PUNCTUATION_KEY_DISPLAY_LABELS;
-exports.WINDOWS_MODIFIER_LABELS = WINDOWS_MODIFIER_LABELS;
-exports.detectPlatform = detectPlatform;
 exports.isSingleLetterKey = isSingleLetterKey;
 exports.normalizeKeyName = normalizeKeyName;
-exports.resolveModifier = resolveModifier;
 //# sourceMappingURL=constants.cjs.map

package/dist/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.cjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["import type {\n  CanonicalModifier,\n  EditingKey,\n  FunctionKey,\n  LetterKey,\n  NavigationKey,\n  NumberKey,\n  PunctuationKey,\n} from './hotkey'\n\n/**\n * Detects the current platform based on browser navigator properties.\n *\n * Used internally to resolve platform-adaptive modifiers like 'Mod' (Command on Mac,\n * Control elsewhere) and for platform-specific hotkey formatting.\n *\n * @returns The detected platform: 'mac', 'windows', or 'linux'\n * @remarks Defaults to 'linux' in SSR environments where navigator is undefined\n *\n * @example\n * ```ts\n * const platform = detectPlatform() // 'mac' | 'windows' | 'linux'\n * const modifier = resolveModifier('Mod', platform) // 'Meta' on Mac, 'Control' elsewhere\n * ```\n */\nexport function detectPlatform(): 'mac' | 'windows' | 'linux' {\n  if (typeof navigator === 'undefined') {\n    return 'linux' // Default for SSR\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const platform = navigator.platform?.toLowerCase() ?? ''\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  const userAgent = navigator.userAgent?.toLowerCase() ?? ''\n\n  if (platform.includes('mac') || userAgent.includes('mac')) {\n    return 'mac'\n  }\n  if (platform.includes('win') || userAgent.includes('win')) {\n    return 'windows'\n  }\n  return 'linux'\n}\n\n/**\n * Canonical order for modifiers in normalized hotkey strings.\n *\n * Defines the standard order in which modifiers should appear when formatting\n * hotkeys. This ensures consistent, predictable output across the library.\n *\n * Order: Control → Alt → Shift → Meta\n *\n * @example\n * ```ts\n * // Input: 'Shift+Control+Meta+S'\n * // Normalized: 'Control+Alt+Shift+Meta+S' (following MODIFIER_ORDER)\n * ```\n */\nexport const MODIFIER_ORDER: Array<CanonicalModifier> = [\n  'Control',\n  'Alt',\n  'Shift',\n  'Meta',\n]\n\n/**\n * Set of canonical modifier key names for fast lookup.\n *\n * Derived from `MODIFIER_ORDER` to ensure consistency. Used to detect when\n * a modifier is released so we can clear non-modifier keys whose keyup events\n * may have been swallowed by the OS (e.g. macOS Cmd+key combos).\n */\nexport const MODIFIER_KEYS = new Set<string>(MODIFIER_ORDER)\n\n/**\n * Maps modifier key aliases to their canonical form or platform-adaptive 'Mod'.\n *\n * This map allows users to write hotkeys using various aliases (e.g., 'Ctrl', 'Cmd', 'Option')\n * which are then normalized to canonical names ('Control', 'Meta', 'Alt') or the\n * platform-adaptive 'Mod' token.\n *\n * The 'Mod' and 'CommandOrControl' aliases are resolved at runtime via `resolveModifier()`\n * based on the detected platform (Command on Mac, Control elsewhere).\n *\n * @remarks Case-insensitive lookups are supported via lowercase variants\n *\n * @example\n * ```ts\n * MODIFIER_ALIASES['Ctrl'] // 'Control'\n * MODIFIER_ALIASES['Cmd'] // 'Meta'\n * MODIFIER_ALIASES['Mod'] // 'Mod' (resolved at runtime)\n * ```\n */\nexport const MODIFIER_ALIASES: Record<string, CanonicalModifier | 'Mod'> = {\n  // Control variants\n  Control: 'Control',\n  Ctrl: 'Control',\n  control: 'Control',\n  ctrl: 'Control',\n\n  // Shift variants\n  Shift: 'Shift',\n  shift: 'Shift',\n\n  // Alt variants\n  Alt: 'Alt',\n  Option: 'Alt',\n  alt: 'Alt',\n  option: 'Alt',\n\n  // Meta/Command variants\n  Command: 'Meta',\n  Cmd: 'Meta',\n  Meta: 'Meta',\n  command: 'Meta',\n  cmd: 'Meta',\n  meta: 'Meta',\n\n  // DOM `KeyboardEvent.key` spellings for the meta / Windows key\n  OS: 'Meta',\n  os: 'Meta',\n  Win: 'Meta',\n  win: 'Meta',\n\n  // Platform-adaptive (resolved at runtime)\n  CommandOrControl: 'Mod',\n  Mod: 'Mod',\n  commandorcontrol: 'Mod',\n  mod: 'Mod',\n}\n\n/**\n * Resolves the platform-adaptive 'Mod' modifier to the appropriate canonical modifier.\n *\n * The 'Mod' token represents the \"primary modifier\" on each platform:\n * - macOS: 'Meta' (Command key ⌘)\n * - Windows/Linux: 'Control' (Ctrl key)\n *\n * This enables cross-platform hotkey definitions like 'Mod+S' that automatically\n * map to Command+S on Mac and Ctrl+S on Windows/Linux.\n *\n * @param modifier - The modifier to resolve. If 'Mod', resolves based on platform.\n * @param platform - The target platform. Defaults to auto-detection.\n * @returns The canonical modifier name ('Control', 'Shift', 'Alt', or 'Meta')\n *\n * @example\n * ```ts\n * resolveModifier('Mod', 'mac') // 'Meta'\n * resolveModifier('Mod', 'windows') // 'Control'\n * resolveModifier('Control', 'mac') // 'Control' (unchanged)\n * ```\n */\nexport function resolveModifier(\n  modifier: CanonicalModifier | 'Mod',\n  platform: 'mac' | 'windows' | 'linux' = detectPlatform(),\n): CanonicalModifier {\n  if (modifier === 'Mod') {\n    return platform === 'mac' ? 'Meta' : 'Control'\n  }\n  return modifier\n}\n\n/**\n * Set of all valid letter keys (A-Z).\n *\n * Used for validation and type checking. Letter keys are matched case-insensitively\n * in hotkey matching, but normalized to uppercase in canonical form.\n */\nexport const LETTER_KEYS = new Set<LetterKey>([\n  'A',\n  'B',\n  'C',\n  'D',\n  'E',\n  'F',\n  'G',\n  'H',\n  'I',\n  'J',\n  'K',\n  'L',\n  'M',\n  'N',\n  'O',\n  'P',\n  'Q',\n  'R',\n  'S',\n  'T',\n  'U',\n  'V',\n  'W',\n  'X',\n  'Y',\n  'Z',\n])\n\n/**\n * Set of all valid number keys (0-9).\n *\n * Note: Number keys are affected by Shift (Shift+1 → '!' on US layout),\n * so they're excluded from Shift-based hotkey combinations to avoid\n * layout-dependent behavior.\n */\nexport const NUMBER_KEYS = new Set<NumberKey>([\n  '0',\n  '1',\n  '2',\n  '3',\n  '4',\n  '5',\n  '6',\n  '7',\n  '8',\n  '9',\n])\n\n/**\n * Set of all valid function keys (F1-F12).\n *\n * Function keys are commonly used for system shortcuts (e.g., F12 for DevTools,\n * Alt+F4 to close windows) and application-specific commands.\n */\nexport const FUNCTION_KEYS = new Set<FunctionKey>([\n  'F1',\n  'F2',\n  'F3',\n  'F4',\n  'F5',\n  'F6',\n  'F7',\n  'F8',\n  'F9',\n  'F10',\n  'F11',\n  'F12',\n])\n\n/**\n * Set of all valid navigation keys for cursor movement and document navigation.\n *\n * Includes arrow keys, Home/End (line navigation), and PageUp/PageDown (page navigation).\n * These keys are commonly combined with modifiers for selection (Shift+ArrowUp) or\n * navigation shortcuts (Alt+ArrowLeft for back).\n */\nexport const NAVIGATION_KEYS = new Set<NavigationKey>([\n  'ArrowUp',\n  'ArrowDown',\n  'ArrowLeft',\n  'ArrowRight',\n  'Home',\n  'End',\n  'PageUp',\n  'PageDown',\n])\n\n/**\n * Set of all valid editing and special keys.\n *\n * Includes keys commonly used for text editing (Enter, Backspace, Delete, Tab) and\n * special actions (Escape, Space). These keys are frequently combined with modifiers\n * for editor shortcuts (Mod+Enter to submit, Shift+Tab to go back).\n */\nexport const EDITING_KEYS = new Set<EditingKey>([\n  'Enter',\n  'Escape',\n  'Space',\n  'Tab',\n  'Backspace',\n  'Delete',\n])\n\n/**\n * Set of all valid punctuation keys commonly used in keyboard shortcuts.\n *\n * These are the literal characters as they appear in `KeyboardEvent.key` (layout-dependent,\n * typically US keyboard layout). Common shortcuts include:\n * - `Mod+/` - Toggle comment\n * - `Mod+[` / `Mod+]` - Indent/outdent\n * - `Mod+=` / `Mod+-` - Zoom in/out\n *\n * Note: Punctuation keys are affected by Shift (Shift+',' → '<' on US layout),\n * so they're excluded from Shift-based hotkey combinations to avoid layout-dependent behavior.\n */\nexport const PUNCTUATION_KEYS = new Set<PunctuationKey>([\n  '/',\n  '[',\n  ']',\n  '\\\\',\n  '=',\n  '-',\n  ',',\n  '.',\n  ';',\n  '`',\n])\n\n/**\n * Maps `KeyboardEvent.code` values for punctuation keys to their canonical characters.\n *\n * On macOS, holding the Option (Alt) key transforms punctuation keys into special characters\n * (e.g., Option+Minus → en-dash '–'), causing `event.key` to differ from the expected character.\n * However, `event.code` still reports the physical key (e.g., 'Minus'). This map enables\n * falling back to `event.code` for punctuation keys, similar to the existing `Key*`/`Digit*`\n * fallbacks for letters and digits.\n */\nexport const PUNCTUATION_CODE_MAP: Record<string, string> = {\n  Backquote: '`',\n  Backslash: '\\\\',\n  BracketLeft: '[',\n  BracketRight: ']',\n  Comma: ',',\n  Equal: '=',\n  Minus: '-',\n  Period: '.',\n  Semicolon: ';',\n  Slash: '/',\n}\n\n/**\n * Set of all valid non-modifier keys.\n *\n * This is the union of all key type sets (letters, numbers, function keys, navigation,\n * editing, and punctuation). Used primarily for validation to check if a key string\n * is recognized and will have type-safe autocomplete support.\n *\n * @see {@link LETTER_KEYS}\n * @see {@link NUMBER_KEYS}\n * @see {@link FUNCTION_KEYS}\n * @see {@link NAVIGATION_KEYS}\n * @see {@link EDITING_KEYS}\n * @see {@link PUNCTUATION_KEYS}\n */\nexport const ALL_KEYS = new Set([\n  ...LETTER_KEYS,\n  ...NUMBER_KEYS,\n  ...FUNCTION_KEYS,\n  ...NAVIGATION_KEYS,\n  ...EDITING_KEYS,\n  ...PUNCTUATION_KEYS,\n])\n\n/**\n * Maps key name aliases to their canonical form.\n *\n * Handles common variations and alternative names for keys to provide a more\n * forgiving API. For example, users can write 'Esc', 'esc', or 'escape' and\n * they'll all normalize to 'Escape'.\n *\n * This map is used internally by `normalizeKeyName()` to convert user input\n * into the canonical key names used throughout the library.\n *\n * @remarks Case-insensitive lookups are supported via lowercase variants\n *\n * @example\n * ```ts\n * KEY_ALIASES['Esc'] // 'Escape'\n * KEY_ALIASES['Del'] // 'Delete'\n * KEY_ALIASES['Up'] // 'ArrowUp'\n * ```\n */\nconst KEY_ALIASES: Record<string, string> = {\n  // Escape variants\n  Esc: 'Escape',\n  esc: 'Escape',\n  escape: 'Escape',\n\n  // Enter variants\n  Return: 'Enter',\n  return: 'Enter',\n  enter: 'Enter',\n\n  // Space variants\n  ' ': 'Space',\n  space: 'Space',\n  Spacebar: 'Space',\n  spacebar: 'Space',\n\n  // Tab variants\n  tab: 'Tab',\n\n  // Backspace variants\n  backspace: 'Backspace',\n\n  // Delete variants\n  Del: 'Delete',\n  del: 'Delete',\n  delete: 'Delete',\n\n  // Arrow key variants\n  Up: 'ArrowUp',\n  up: 'ArrowUp',\n  arrowup: 'ArrowUp',\n  Down: 'ArrowDown',\n  down: 'ArrowDown',\n  arrowdown: 'ArrowDown',\n  Left: 'ArrowLeft',\n  left: 'ArrowLeft',\n  arrowleft: 'ArrowLeft',\n  Right: 'ArrowRight',\n  right: 'ArrowRight',\n  arrowright: 'ArrowRight',\n\n  // Navigation variants\n  home: 'Home',\n  end: 'End',\n  pageup: 'PageUp',\n  pagedown: 'PageDown',\n  PgUp: 'PageUp',\n  PgDn: 'PageDown',\n  pgup: 'PageUp',\n  pgdn: 'PageDown',\n}\n\n/**\n * Normalizes a key name to its canonical form.\n *\n * Converts various key name formats (aliases, case variations) into the standard\n * canonical names used throughout the library. This enables a more forgiving API\n * where users can write keys in different ways and still get correct behavior.\n *\n * Normalization rules:\n * 1. Check aliases first (e.g., 'Esc' → 'Escape', 'Del' → 'Delete')\n * 2. Single letters → uppercase (e.g., 'a' → 'A', 's' → 'S')\n * 3. Function keys → uppercase (e.g., 'f1' → 'F1', 'F12' → 'F12')\n * 4. Other keys → returned as-is (already canonical or unknown)\n *\n * @param key - The key name to normalize (can be an alias, lowercase, etc.)\n * @returns The canonical key name\n *\n * @example\n * ```ts\n * normalizeKeyName('esc') // 'Escape'\n * normalizeKeyName('a') // 'A'\n * normalizeKeyName('f1') // 'F1'\n * normalizeKeyName('ArrowUp') // 'ArrowUp' (already canonical)\n * ```\n */\nexport function isSingleLetterKey(key: string): boolean {\n  return /^\\p{Letter}$/u.test(key)\n}\n\n/**\n * Normalizes a key name to its canonical form.\n *\n * @param key - The key name to normalize (can be an alias, lowercase, etc.)\n * @returns The canonical key name\n *\n * @example\n * ```ts\n * normalizeKeyName('esc') // 'Escape'\n * normalizeKeyName('a') // 'A'\n * normalizeKeyName('f1') // 'F1'\n * normalizeKeyName('ArrowUp') // 'ArrowUp' (already canonical)\n * ```\n */\nexport function normalizeKeyName(key: string): string {\n  // key can be undefined in rare cases\n  // (browser extensions synthesizing key events, accessibility tools, certain OS/browser combinations).\n  if (!key) return ''\n  // Check aliases first\n  if (key in KEY_ALIASES) {\n    return KEY_ALIASES[key]!\n  }\n\n  if (isSingleLetterKey(key)) {\n    const upper = key.toUpperCase()\n    // Some Unicode letters (e.g., 'ß') uppercase to multi-character sequences\n    // ('SS'). Avoid changing the string length so the rest of the matching\n    // logic can rely on a stable single-character key value.\n    return upper.length === 1 ? upper : key\n  }\n\n  // Check if it's a function key (normalize case)\n  const upperKey = key.toUpperCase()\n  if (/^F([1-9]|1[0-2])$/.test(upperKey)) {\n    return upperKey\n  }\n\n  return key\n}\n\n// =============================================================================\n// Display Symbols\n// =============================================================================\n\n/**\n * Modifier key symbols for macOS display.\n *\n * Used by formatting functions to display hotkeys with macOS-style symbols\n * (e.g., ⌘ for Command, ⌃ for Control) instead of text labels. This provides\n * a native macOS look and feel in hotkey displays.\n *\n * @example\n * ```ts\n * MAC_MODIFIER_SYMBOLS['Meta'] // '⌘'\n * MAC_MODIFIER_SYMBOLS['Control'] // '⌃'\n * MAC_MODIFIER_SYMBOLS['Alt'] // '⌥'\n * MAC_MODIFIER_SYMBOLS['Shift'] // '⇧'\n * ```\n */\nexport const MAC_MODIFIER_SYMBOLS: Record<CanonicalModifier | 'Mod', string> = {\n  Control: '⌃',\n  Alt: '⌥',\n  Shift: '⇧',\n  Meta: '⌘',\n  Mod: '⌘',\n}\n\n/**\n * Modifier key labels for macOS display.\n *\n * Used by formatting functions to display hotkeys with macOS-style text labels\n * (e.g., 'Control' for Control, 'Option' for Alt, 'Cmd' for Meta) instead of symbols.\n * This provides a familiar macOS look and feel in hotkey displays.\n *\n * @example\n * ```ts\n * MAC_MODIFIER_LABELS['Control'] // 'control'\n * MAC_MODIFIER_LABELS['Alt'] // 'option'\n * MAC_MODIFIER_LABELS['Shift'] // 'shift'\n * MAC_MODIFIER_LABELS['Meta'] // 'cmd'\n * ```\n */\nexport const MAC_MODIFIER_LABELS: Record<CanonicalModifier | 'Mod', string> = {\n  Control: 'Control',\n  Alt: 'Option',\n  Shift: 'Shift',\n  Meta: 'Cmd',\n  Mod: 'Cmd',\n}\n\n/**\n * Modifier key labels for Windows/Linux display.\n *\n * Used by formatting functions to display hotkeys with standard text labels\n * (e.g., 'Ctrl' for Control, 'Win' for Meta/Windows key) instead of symbols.\n * This provides a familiar Windows/Linux look and feel in hotkey displays.\n *\n * @example\n * ```ts\n * STANDARD_MODIFIER_LABELS['Control'] // 'Ctrl'\n * STANDARD_MODIFIER_LABELS['Meta'] // 'Win'\n * STANDARD_MODIFIER_LABELS['Alt'] // 'Alt'\n * STANDARD_MODIFIER_LABELS['Shift'] // 'Shift'\n * ```\n */\nexport const WINDOWS_MODIFIER_LABELS: Record<\n  CanonicalModifier | 'Mod',\n  string\n> = {\n  Control: 'Ctrl',\n  Alt: 'Alt',\n  Shift: 'Shift',\n  Meta: 'Win',\n  Mod: 'Ctrl',\n}\n\nexport const LINUX_MODIFIER_LABELS: Record<CanonicalModifier | 'Mod', string> =\n  {\n    ...WINDOWS_MODIFIER_LABELS,\n    Meta: 'Super',\n  }\n\nexport const PUNCTUATION_KEY_DISPLAY_LABELS = {\n  '`': 'Backquote',\n  '\\\\': 'Backslash',\n  '[': 'Left Bracket',\n  ']': 'Right Bracket',\n  ',': 'Comma',\n  '=': 'Equal',\n  '-': 'Minus',\n  '.': 'Period',\n  ';': 'Semicolon',\n} as const satisfies Record<string, string>\n\n/**\n * Special key symbols for display formatting.\n *\n * Maps certain keys to their visual symbols for better readability in hotkey displays.\n * Used by formatting functions to show symbols like ↑ for ArrowUp or ↵ for Enter\n * instead of text labels.\n *\n * @example\n * ```ts\n * KEY_DISPLAY_SYMBOLS['ArrowUp'] // '↑'\n * KEY_DISPLAY_SYMBOLS['Enter'] // '↵'\n * KEY_DISPLAY_SYMBOLS['Escape'] // 'Esc'\n * KEY_DISPLAY_SYMBOLS['Space'] // '␣'\n * ```\n */\nexport const KEY_DISPLAY_SYMBOLS = {\n  ArrowUp: '↑',\n  ArrowDown: '↓',\n  ArrowLeft: '←',\n  ArrowRight: '→',\n  Enter: '↵',\n  Escape: 'Esc',\n  Backspace: '⌫',\n  Delete: '⌦',\n  Tab: '⇥',\n  Space: '␣',\n} as const satisfies Record<string, string>\n"],"mappings":"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"}
+{"version":3,"file":"constants.cjs","names":["SHARED_NAMED_KEYS","LOGICAL_ONLY_NAMED_KEYS"],"sources":["../src/constants.ts"],"sourcesContent":["import { LOGICAL_ONLY_NAMED_KEYS, SHARED_NAMED_KEYS } from './_named-keys'\nimport type {\n  CanonicalModifier,\n  EditingKey,\n  FunctionKey,\n  LetterKey,\n  NavigationKey,\n  NumberKey,\n  PunctuationKey,\n} from './key.types'\n\n/**\n * Canonical order for modifiers in normalized hotkey strings.\n *\n * Defines the standard order in which modifiers should appear when formatting\n * hotkeys. This ensures consistent, predictable output across the library.\n *\n * Order: Control → Alt → Shift → Meta\n *\n * @example\n * ```ts\n * // Input: 'Shift+Control+Meta+S'\n * // Normalized: 'Control+Alt+Shift+Meta+S' (following MODIFIER_ORDER)\n * ```\n */\nexport const MODIFIER_ORDER: Array<CanonicalModifier> = [\n  'Control',\n  'Alt',\n  'Shift',\n  'Meta',\n]\n\n/**\n * Set of canonical modifier key names for fast lookup.\n *\n * Derived from `MODIFIER_ORDER` to ensure consistency. Used to detect when\n * a modifier is released so we can clear non-modifier keys whose keyup events\n * may have been swallowed by the OS (e.g. macOS Cmd+key combos).\n */\nexport const MODIFIER_KEYS = new Set<string>(MODIFIER_ORDER)\n\n/**\n * Maps modifier key aliases to their canonical form or platform-adaptive 'Mod'.\n *\n * This map allows users to write hotkeys using various aliases (e.g., 'Ctrl', 'Cmd', 'Option')\n * which are then normalized to canonical names ('Control', 'Meta', 'Alt') or the\n * platform-adaptive 'Mod' token.\n *\n * The 'Mod' and 'CommandOrControl' aliases are resolved at runtime via `resolveModifier()`\n * based on the detected platform (Command on Mac, Control elsewhere).\n *\n * @remarks Case-insensitive lookups are supported via lowercase variants\n *\n * @example\n * ```ts\n * MODIFIER_ALIASES['Ctrl'] // 'Control'\n * MODIFIER_ALIASES['Cmd'] // 'Meta'\n * MODIFIER_ALIASES['Mod'] // 'Mod' (resolved at runtime)\n * ```\n */\nexport const MODIFIER_ALIASES: Record<string, CanonicalModifier | 'Mod'> = {\n  // Control variants\n  Control: 'Control',\n  Ctrl: 'Control',\n  control: 'Control',\n  ctrl: 'Control',\n\n  // Shift variants\n  Shift: 'Shift',\n  shift: 'Shift',\n\n  // Alt variants\n  Alt: 'Alt',\n  Option: 'Alt',\n  alt: 'Alt',\n  option: 'Alt',\n\n  // Meta/Command variants\n  Command: 'Meta',\n  Cmd: 'Meta',\n  Meta: 'Meta',\n  command: 'Meta',\n  cmd: 'Meta',\n  meta: 'Meta',\n\n  // DOM `KeyboardEvent.key` spellings for the meta / Windows key\n  OS: 'Meta',\n  os: 'Meta',\n  Win: 'Meta',\n  win: 'Meta',\n\n  // Platform-adaptive (resolved at runtime)\n  CommandOrControl: 'Mod',\n  Mod: 'Mod',\n  commandorcontrol: 'Mod',\n  mod: 'Mod',\n}\n\n/**\n * Set of all valid letter keys (A-Z).\n *\n * Used for validation and type checking. Letter keys are matched case-insensitively\n * in hotkey matching, but normalized to uppercase in canonical form.\n */\nexport const LETTER_KEYS = new Set<LetterKey>([\n  'A',\n  'B',\n  'C',\n  'D',\n  'E',\n  'F',\n  'G',\n  'H',\n  'I',\n  'J',\n  'K',\n  'L',\n  'M',\n  'N',\n  'O',\n  'P',\n  'Q',\n  'R',\n  'S',\n  'T',\n  'U',\n  'V',\n  'W',\n  'X',\n  'Y',\n  'Z',\n])\n\n/**\n * Set of all valid number keys (0-9).\n *\n * Note: Number keys are affected by Shift (Shift+1 → '!' on US layout),\n * so they're excluded from Shift-based hotkey combinations to avoid\n * layout-dependent behavior.\n */\nexport const NUMBER_KEYS = new Set<NumberKey>([\n  '0',\n  '1',\n  '2',\n  '3',\n  '4',\n  '5',\n  '6',\n  '7',\n  '8',\n  '9',\n])\n\n/**\n * Set of all valid function keys (F1-F24).\n *\n * Function keys are commonly used for system shortcuts (e.g., F12 for DevTools,\n * Alt+F4 to close windows) and application-specific commands.\n */\nexport const FUNCTION_KEYS = new Set<FunctionKey>([\n  'F1',\n  'F2',\n  'F3',\n  'F4',\n  'F5',\n  'F6',\n  'F7',\n  'F8',\n  'F9',\n  'F10',\n  'F11',\n  'F12',\n  'F13',\n  'F14',\n  'F15',\n  'F16',\n  'F17',\n  'F18',\n  'F19',\n  'F20',\n  'F21',\n  'F22',\n  'F23',\n  'F24',\n])\n\n/**\n * Set of all valid navigation keys for cursor movement and document navigation.\n *\n * Includes arrow keys, Home/End (line navigation), and PageUp/PageDown (page navigation).\n * These keys are commonly combined with modifiers for selection (Shift+ArrowUp) or\n * navigation shortcuts (Alt+ArrowLeft for back).\n */\nexport const NAVIGATION_KEYS = new Set<NavigationKey>([\n  'ArrowUp',\n  'ArrowDown',\n  'ArrowLeft',\n  'ArrowRight',\n  'Home',\n  'End',\n  'PageUp',\n  'PageDown',\n])\n\n/**\n * Set of all valid editing and special keys.\n *\n * Includes keys commonly used for text editing (Enter, Backspace, Delete, Tab) and\n * special actions (Escape, Space). These keys are frequently combined with modifiers\n * for editor shortcuts (Mod+Enter to submit, Shift+Tab to go back).\n */\nexport const EDITING_KEYS = new Set<EditingKey>([\n  'Enter',\n  'Escape',\n  'Space',\n  'Tab',\n  'Backspace',\n  'Delete',\n])\n\n/**\n * Set of all valid punctuation keys commonly used in keyboard shortcuts.\n *\n * These are the literal characters as they appear in `KeyboardEvent.key` (layout-dependent,\n * typically US keyboard layout). Common shortcuts include:\n * - `Mod+/` - Toggle comment\n * - `Mod+[` / `Mod+]` - Indent/outdent\n * - `Mod+=` / `Mod+-` - Zoom in/out\n *\n * Note: Punctuation keys are affected by Shift (Shift+',' → '<' on US layout),\n * so they're excluded from Shift-based hotkey combinations to avoid layout-dependent behavior.\n */\nexport const PUNCTUATION_KEYS = new Set<PunctuationKey>([\n  '/',\n  '[',\n  ']',\n  '\\\\',\n  '=',\n  '-',\n  ',',\n  '.',\n  ';',\n  '`',\n  \"'\",\n  '+',\n  '?',\n  '!',\n  '@',\n  '#',\n  '$',\n  '%',\n  '^',\n  '&',\n  '*',\n  '(',\n  ')',\n  '_',\n  '{',\n  '}',\n  '|',\n  ':',\n  '\"',\n  '<',\n  '>',\n  '~',\n])\n\n/**\n * Maps `KeyboardEvent.code` values for punctuation keys to their canonical characters.\n *\n * On macOS, holding the Option (Alt) key transforms punctuation keys into special characters\n * (e.g., Option+Minus → en-dash '–'), causing `event.key` to differ from the expected character.\n * However, `event.code` still reports the physical key (e.g., 'Minus'). This map enables\n * falling back to `event.code` for punctuation keys, similar to the existing `Key*`/`Digit*`\n * fallbacks for letters and digits.\n */\nexport const PUNCTUATION_CODE_MAP: Record<string, string> = {\n  Backquote: '`',\n  Backslash: '\\\\',\n  BracketLeft: '[',\n  BracketRight: ']',\n  Comma: ',',\n  Equal: '=',\n  Minus: '-',\n  Period: '.',\n  Quote: \"'\",\n  Semicolon: ';',\n  Slash: '/',\n}\n\n/**\n * Set of all valid non-modifier keys.\n *\n * This is the union of all key type sets (letters, numbers, function keys, navigation,\n * editing, and punctuation). Used primarily for validation to check if a key string\n * is recognized and will have type-safe autocomplete support.\n *\n * @see {@link LETTER_KEYS}\n * @see {@link NUMBER_KEYS}\n * @see {@link FUNCTION_KEYS}\n * @see {@link NAVIGATION_KEYS}\n * @see {@link EDITING_KEYS}\n * @see {@link PUNCTUATION_KEYS}\n */\nexport const ALL_KEYS = new Set([\n  ...LETTER_KEYS,\n  ...NUMBER_KEYS,\n  ...FUNCTION_KEYS,\n  ...NAVIGATION_KEYS,\n  ...EDITING_KEYS,\n  ...PUNCTUATION_KEYS,\n  ...SHARED_NAMED_KEYS,\n  ...LOGICAL_ONLY_NAMED_KEYS,\n])\n\n// Share canonical spellings with validation, including newly supported named keys.\nconst CANONICAL_KEY_NAMES = new Map<string, string>(\n  Array.from(ALL_KEYS, (key) => [key.toLowerCase(), key]),\n)\n\n/**\n * Maps key name aliases to their canonical form.\n *\n * Handles common variations and alternative names for keys to provide a more\n * forgiving API. For example, users can write 'Esc', 'esc', or 'escape' and\n * they'll all normalize to 'Escape'.\n *\n * This map is used internally by `normalizeKeyName()` to convert user input\n * into the canonical key names used throughout the library.\n *\n * @remarks Case-insensitive lookups are supported via lowercase variants\n *\n * @example\n * ```ts\n * KEY_ALIASES['Esc'] // 'Escape'\n * KEY_ALIASES['Del'] // 'Delete'\n * KEY_ALIASES['Up'] // 'ArrowUp'\n * ```\n */\nconst KEY_ALIASES: Record<string, string> = {\n  Plus: '+',\n  plus: '+',\n  // Escape variants\n  Esc: 'Escape',\n  esc: 'Escape',\n  escape: 'Escape',\n\n  // Enter variants\n  Return: 'Enter',\n  return: 'Enter',\n  enter: 'Enter',\n\n  // Space variants\n  ' ': 'Space',\n  space: 'Space',\n  Spacebar: 'Space',\n  spacebar: 'Space',\n\n  // Tab variants\n  tab: 'Tab',\n\n  // Backspace variants\n  backspace: 'Backspace',\n\n  // Delete variants\n  Del: 'Delete',\n  del: 'Delete',\n  delete: 'Delete',\n\n  // Arrow key variants\n  Up: 'ArrowUp',\n  up: 'ArrowUp',\n  arrowup: 'ArrowUp',\n  Down: 'ArrowDown',\n  down: 'ArrowDown',\n  arrowdown: 'ArrowDown',\n  Left: 'ArrowLeft',\n  left: 'ArrowLeft',\n  arrowleft: 'ArrowLeft',\n  Right: 'ArrowRight',\n  right: 'ArrowRight',\n  arrowright: 'ArrowRight',\n\n  // Navigation variants\n  home: 'Home',\n  end: 'End',\n  pageup: 'PageUp',\n  pagedown: 'PageDown',\n  PgUp: 'PageUp',\n  PgDn: 'PageDown',\n  pgup: 'PageUp',\n  pgdn: 'PageDown',\n}\n\n/**\n * Normalizes a key name to its canonical form.\n *\n * Converts various key name formats (aliases, case variations) into the standard\n * canonical names used throughout the library. This enables a more forgiving API\n * where users can write keys in different ways and still get correct behavior.\n *\n * Normalization rules:\n * 1. Check aliases first (e.g., 'Esc' → 'Escape', 'Del' → 'Delete')\n * 2. Single letters → uppercase (e.g., 'a' → 'A', 's' → 'S')\n * 3. Function keys → uppercase (e.g., 'f1' → 'F1', 'F12' → 'F12')\n * 4. Other keys → returned as-is (already canonical or unknown)\n *\n * @param key - The key name to normalize (can be an alias, lowercase, etc.)\n * @returns The canonical key name\n *\n * @example\n * ```ts\n * normalizeKeyName('esc') // 'Escape'\n * normalizeKeyName('a') // 'A'\n * normalizeKeyName('f1') // 'F1'\n * normalizeKeyName('ArrowUp') // 'ArrowUp' (already canonical)\n * ```\n */\nexport function isSingleLetterKey(key: string): boolean {\n  return /^\\p{Letter}$/u.test(key)\n}\n\n/**\n * Normalizes a key name to its canonical form.\n *\n * @param key - The key name to normalize (can be an alias, lowercase, etc.)\n * @returns The canonical key name\n *\n * @example\n * ```ts\n * normalizeKeyName('esc') // 'Escape'\n * normalizeKeyName('a') // 'A'\n * normalizeKeyName('f1') // 'F1'\n * normalizeKeyName('ArrowUp') // 'ArrowUp' (already canonical)\n * ```\n */\nexport function normalizeKeyName(key: string): string {\n  // key can be undefined in rare cases\n  // (browser extensions synthesizing key events, accessibility tools, certain OS/browser combinations).\n  if (!key) return ''\n  // Check aliases first\n  if (key in KEY_ALIASES) {\n    return KEY_ALIASES[key]!\n  }\n\n  if (isSingleLetterKey(key)) {\n    const upper = key.toUpperCase()\n    // Some Unicode letters (e.g., 'ß') uppercase to multi-character sequences\n    // ('SS'). Avoid changing the string length so the rest of the matching\n    // logic can rely on a stable single-character key value.\n    return upper.length === 1 ? upper : key\n  }\n\n  return CANONICAL_KEY_NAMES.get(key.toLowerCase()) ?? key\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBA,MAAa,iBAA2C;CACtD;CACA;CACA;CACA;CACD;;;;;;;;AASD,MAAa,gBAAgB,IAAI,IAAY,eAAe;;;;;;;;;;;;;;;;;;;;AAqB5D,MAAa,mBAA8D;CAEzE,SAAS;CACT,MAAM;CACN,SAAS;CACT,MAAM;CAGN,OAAO;CACP,OAAO;CAGP,KAAK;CACL,QAAQ;CACR,KAAK;CACL,QAAQ;CAGR,SAAS;CACT,KAAK;CACL,MAAM;CACN,SAAS;CACT,KAAK;CACL,MAAM;CAGN,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;CAGL,kBAAkB;CAClB,KAAK;CACL,kBAAkB;CAClB,KAAK;CACN;;;;;;;AAQD,MAAa,cAAc,IAAI,IAAe;CAC5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;AASF,MAAa,cAAc,IAAI,IAAe;CAC5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;AAQF,MAAa,gBAAgB,IAAI,IAAiB;CAChD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;AASF,MAAa,kBAAkB,IAAI,IAAmB;CACpD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;AASF,MAAa,eAAe,IAAI,IAAgB;CAC9C;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;AAcF,MAAa,mBAAmB,IAAI,IAAoB;CACtD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;AAWF,MAAa,uBAA+C;CAC1D,WAAW;CACX,WAAW;CACX,aAAa;CACb,cAAc;CACd,OAAO;CACP,OAAO;CACP,OAAO;CACP,QAAQ;CACR,OAAO;CACP,WAAW;CACX,OAAO;CACR;;;;;;;;;;;;;;;AAgBD,MAAa,WAAW,IAAI,IAAI;CAC9B,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAGA;CACH,GAAGC;CACJ,CAAC;AAGF,MAAM,sBAAsB,IAAI,IAC9B,MAAM,KAAK,WAAW,QAAQ,CAAC,IAAI,aAAa,EAAE,IAAI,CAAC,CACxD;;;;;;;;;;;;;;;;;;;;AAqBD,MAAM,cAAsC;CAC1C,MAAM;CACN,MAAM;CAEN,KAAK;CACL,KAAK;CACL,QAAQ;CAGR,QAAQ;CACR,QAAQ;CACR,OAAO;CAGP,KAAK;CACL,OAAO;CACP,UAAU;CACV,UAAU;CAGV,KAAK;CAGL,WAAW;CAGX,KAAK;CACL,KAAK;CACL,QAAQ;CAGR,IAAI;CACJ,IAAI;CACJ,SAAS;CACT,MAAM;CACN,MAAM;CACN,WAAW;CACX,MAAM;CACN,MAAM;CACN,WAAW;CACX,OAAO;CACP,OAAO;CACP,YAAY;CAGZ,MAAM;CACN,KAAK;CACL,QAAQ;CACR,UAAU;CACV,MAAM;CACN,MAAM;CACN,MAAM;CACN,MAAM;CACP;;;;;;;;;;;;;;;;;;;;;;;;;AA0BD,SAAgB,kBAAkB,KAAsB;AACtD,QAAO,gBAAgB,KAAK,IAAI;;;;;;;;;;;;;;;;AAiBlC,SAAgB,iBAAiB,KAAqB;AAGpD,KAAI,CAAC,IAAK,QAAO;AAEjB,KAAI,OAAO,YACT,QAAO,YAAY;AAGrB,KAAI,kBAAkB,IAAI,EAAE;EAC1B,MAAM,QAAQ,IAAI,aAAa;AAI/B,SAAO,MAAM,WAAW,IAAI,QAAQ;;AAGtC,QAAO,oBAAoB,IAAI,IAAI,aAAa,CAAC,IAAI"}

package/dist/constants.d.cts

@@ -1,22 +1,6 @@
-import { CanonicalModifier, EditingKey, FunctionKey, LetterKey, NavigationKey, NumberKey, PunctuationKey } from "./hotkey.cjs";
+import { CanonicalModifier, EditingKey, FunctionKey, LetterKey, NavigationKey, NumberKey, PunctuationKey } from "./key.types.cjs";
 
 //#region src/constants.d.ts
-/**
- * Detects the current platform based on browser navigator properties.
- *
- * Used internally to resolve platform-adaptive modifiers like 'Mod' (Command on Mac,
- * Control elsewhere) and for platform-specific hotkey formatting.
- *
- * @returns The detected platform: 'mac', 'windows', or 'linux'
- * @remarks Defaults to 'linux' in SSR environments where navigator is undefined
- *
- * @example
- * ```ts
- * const platform = detectPlatform() // 'mac' | 'windows' | 'linux'
- * const modifier = resolveModifier('Mod', platform) // 'Meta' on Mac, 'Control' elsewhere
- * ```
- */
-declare function detectPlatform(): 'mac' | 'windows' | 'linux';
 /**
  * Canonical order for modifiers in normalized hotkey strings.
  *
@@ -60,28 +44,6 @@ declare const MODIFIER_KEYS: Set<string>;
  * ```
  */
 declare const MODIFIER_ALIASES: Record<string, CanonicalModifier | 'Mod'>;
-/**
- * Resolves the platform-adaptive 'Mod' modifier to the appropriate canonical modifier.
- *
- * The 'Mod' token represents the "primary modifier" on each platform:
- * - macOS: 'Meta' (Command key ⌘)
- * - Windows/Linux: 'Control' (Ctrl key)
- *
- * This enables cross-platform hotkey definitions like 'Mod+S' that automatically
- * map to Command+S on Mac and Ctrl+S on Windows/Linux.
- *
- * @param modifier - The modifier to resolve. If 'Mod', resolves based on platform.
- * @param platform - The target platform. Defaults to auto-detection.
- * @returns The canonical modifier name ('Control', 'Shift', 'Alt', or 'Meta')
- *
- * @example
- * ```ts
- * resolveModifier('Mod', 'mac') // 'Meta'
- * resolveModifier('Mod', 'windows') // 'Control'
- * resolveModifier('Control', 'mac') // 'Control' (unchanged)
- * ```
- */
-declare function resolveModifier(modifier: CanonicalModifier | 'Mod', platform?: 'mac' | 'windows' | 'linux'): CanonicalModifier;
 /**
  * Set of all valid letter keys (A-Z).
  *
@@ -98,7 +60,7 @@ declare const LETTER_KEYS: Set<LetterKey>;
  */
 declare const NUMBER_KEYS: Set<NumberKey>;
 /**
- * Set of all valid function keys (F1-F12).
+ * Set of all valid function keys (F1-F24).
  *
  * Function keys are commonly used for system shortcuts (e.g., F12 for DevTools,
  * Alt+F4 to close windows) and application-specific commands.
@@ -157,7 +119,7 @@ declare const PUNCTUATION_CODE_MAP: Record<string, string>;
  * @see {@link EDITING_KEYS}
  * @see {@link PUNCTUATION_KEYS}
  */
-declare const ALL_KEYS: Set<LetterKey | NumberKey | FunctionKey | NavigationKey | EditingKey | PunctuationKey>;
+declare const ALL_KEYS: Set<LetterKey | NumberKey | FunctionKey | NavigationKey | EditingKey | PunctuationKey | "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" | "Clear" | "Cancel" | "Standby" | "LaunchApplication1" | "LaunchApplication2" | "LaunchMediaPlayer" | "HangulMode" | "HanjaMode" | "Zenkaku" | "Hankaku" | "ZenkakuHankaku">;
 /**
  * Normalizes a key name to its canonical form.
  *
@@ -198,93 +160,6 @@ declare function isSingleLetterKey(key: string): boolean;
  * ```
  */
 declare function normalizeKeyName(key: string): string;
-/**
- * Modifier key symbols for macOS display.
- *
- * Used by formatting functions to display hotkeys with macOS-style symbols
- * (e.g., ⌘ for Command, ⌃ for Control) instead of text labels. This provides
- * a native macOS look and feel in hotkey displays.
- *
- * @example
- * ```ts
- * MAC_MODIFIER_SYMBOLS['Meta'] // '⌘'
- * MAC_MODIFIER_SYMBOLS['Control'] // '⌃'
- * MAC_MODIFIER_SYMBOLS['Alt'] // '⌥'
- * MAC_MODIFIER_SYMBOLS['Shift'] // '⇧'
- * ```
- */
-declare const MAC_MODIFIER_SYMBOLS: Record<CanonicalModifier | 'Mod', string>;
-/**
- * Modifier key labels for macOS display.
- *
- * Used by formatting functions to display hotkeys with macOS-style text labels
- * (e.g., 'Control' for Control, 'Option' for Alt, 'Cmd' for Meta) instead of symbols.
- * This provides a familiar macOS look and feel in hotkey displays.
- *
- * @example
- * ```ts
- * MAC_MODIFIER_LABELS['Control'] // 'control'
- * MAC_MODIFIER_LABELS['Alt'] // 'option'
- * MAC_MODIFIER_LABELS['Shift'] // 'shift'
- * MAC_MODIFIER_LABELS['Meta'] // 'cmd'
- * ```
- */
-declare const MAC_MODIFIER_LABELS: Record<CanonicalModifier | 'Mod', string>;
-/**
- * Modifier key labels for Windows/Linux display.
- *
- * Used by formatting functions to display hotkeys with standard text labels
- * (e.g., 'Ctrl' for Control, 'Win' for Meta/Windows key) instead of symbols.
- * This provides a familiar Windows/Linux look and feel in hotkey displays.
- *
- * @example
- * ```ts
- * STANDARD_MODIFIER_LABELS['Control'] // 'Ctrl'
- * STANDARD_MODIFIER_LABELS['Meta'] // 'Win'
- * STANDARD_MODIFIER_LABELS['Alt'] // 'Alt'
- * STANDARD_MODIFIER_LABELS['Shift'] // 'Shift'
- * ```
- */
-declare const WINDOWS_MODIFIER_LABELS: Record<CanonicalModifier | 'Mod', string>;
-declare const LINUX_MODIFIER_LABELS: Record<CanonicalModifier | 'Mod', string>;
-declare const PUNCTUATION_KEY_DISPLAY_LABELS: {
-  readonly '`': "Backquote";
-  readonly '\\': "Backslash";
-  readonly '[': "Left Bracket";
-  readonly ']': "Right Bracket";
-  readonly ',': "Comma";
-  readonly '=': "Equal";
-  readonly '-': "Minus";
-  readonly '.': "Period";
-  readonly ';': "Semicolon";
-};
-/**
- * Special key symbols for display formatting.
- *
- * Maps certain keys to their visual symbols for better readability in hotkey displays.
- * Used by formatting functions to show symbols like ↑ for ArrowUp or ↵ for Enter
- * instead of text labels.
- *
- * @example
- * ```ts
- * KEY_DISPLAY_SYMBOLS['ArrowUp'] // '↑'
- * KEY_DISPLAY_SYMBOLS['Enter'] // '↵'
- * KEY_DISPLAY_SYMBOLS['Escape'] // 'Esc'
- * KEY_DISPLAY_SYMBOLS['Space'] // '␣'
- * ```
- */
-declare const KEY_DISPLAY_SYMBOLS: {
-  readonly ArrowUp: "↑";
-  readonly ArrowDown: "↓";
-  readonly ArrowLeft: "←";
-  readonly ArrowRight: "→";
-  readonly Enter: "↵";
-  readonly Escape: "Esc";
-  readonly Backspace: "⌫";
-  readonly Delete: "⌦";
-  readonly Tab: "⇥";
-  readonly Space: "␣";
-};
 //#endregion
-export { ALL_KEYS, EDITING_KEYS, FUNCTION_KEYS, KEY_DISPLAY_SYMBOLS, LETTER_KEYS, LINUX_MODIFIER_LABELS, MAC_MODIFIER_LABELS, MAC_MODIFIER_SYMBOLS, MODIFIER_ALIASES, MODIFIER_KEYS, MODIFIER_ORDER, NAVIGATION_KEYS, NUMBER_KEYS, PUNCTUATION_CODE_MAP, PUNCTUATION_KEYS, PUNCTUATION_KEY_DISPLAY_LABELS, WINDOWS_MODIFIER_LABELS, detectPlatform, isSingleLetterKey, normalizeKeyName, resolveModifier };
+export { ALL_KEYS, EDITING_KEYS, FUNCTION_KEYS, LETTER_KEYS, MODIFIER_ALIASES, MODIFIER_KEYS, MODIFIER_ORDER, NAVIGATION_KEYS, NUMBER_KEYS, PUNCTUATION_CODE_MAP, PUNCTUATION_KEYS, isSingleLetterKey, normalizeKeyName };
 //# sourceMappingURL=constants.d.cts.map