@redis-ui/components 47.4.0 → 47.5.1

package/dist/node_modules/@tanstack/hotkeys/dist/hotkey-manager.js

@@ -0,0 +1,363 @@
+import { detectPlatform, normalizeKeyName } from "./constants.js";
+import { parseHotkey, rawHotkeyToParsedHotkey } from "./parse.js";
+import { formatHotkey } from "./format.js";
+import { matchesKeyboardEvent } from "./match.js";
+import { defaultHotkeyOptions, getDefaultIgnoreInputs, handleConflict, isEventForTarget, shouldIgnoreInputEvent } from "./manager.utils.js";
+import { Store } from "../../store/dist/store.js";
+//#region ../../node_modules/@tanstack/hotkeys/dist/hotkey-manager.js
+var registrationIdCounter = 0;
+/**
+* Generates a unique ID for hotkey registrations.
+*/
+function generateId() {
+	return `hotkey_${++registrationIdCounter}`;
+}
+/**
+* Singleton manager for hotkey registrations.
+*
+* This class provides a centralized way to register and manage keyboard hotkeys.
+* It uses a single event listener for efficiency, regardless of how many hotkeys
+* are registered.
+*
+* @example
+* ```ts
+* const manager = HotkeyManager.getInstance()
+*
+* const unregister = manager.register('Mod+S', (event, context) => {
+*   console.log('Save triggered!')
+* })
+*
+* // Later, to unregister:
+* unregister()
+* ```
+*/
+var HotkeyManager = class HotkeyManager {
+	static #instance = null;
+	#platform;
+	#targetListeners = /* @__PURE__ */ new Map();
+	#targetRegistrations = /* @__PURE__ */ new Map();
+	constructor() {
+		this.registrations = new Store(/* @__PURE__ */ new Map());
+		this.#platform = detectPlatform();
+	}
+	/**
+	* Gets the singleton instance of HotkeyManager.
+	*/
+	static getInstance() {
+		if (!HotkeyManager.#instance) HotkeyManager.#instance = new HotkeyManager();
+		return HotkeyManager.#instance;
+	}
+	/**
+	* Resets the singleton instance. Useful for testing.
+	*/
+	static resetInstance() {
+		if (HotkeyManager.#instance) {
+			HotkeyManager.#instance.destroy();
+			HotkeyManager.#instance = null;
+		}
+	}
+	/**
+	* Registers a hotkey handler and returns a handle for updating the registration.
+	*
+	* The returned handle allows updating the callback and options without
+	* re-registering, which is useful for avoiding stale closures in React.
+	*
+	* @param hotkey - The hotkey string (e.g., 'Mod+S') or RawHotkey object
+	* @param callback - The function to call when the hotkey is pressed
+	* @param options - Options for the hotkey behavior
+	* @returns A handle for managing the registration
+	*
+	* @example
+	* ```ts
+	* const handle = manager.register('Mod+S', callback)
+	*
+	* // Update callback without re-registering (avoids stale closures)
+	* handle.callback = newCallback
+	*
+	* // Update options
+	* handle.setOptions({ enabled: false })
+	*
+	* // Unregister when done
+	* handle.unregister()
+	* ```
+	*/
+	register(hotkey, callback, options = {}) {
+		if (typeof document === "undefined" && !options.target) {
+			let currentCallback = callback;
+			return {
+				id: generateId(),
+				unregister: () => {},
+				get callback() {
+					return currentCallback;
+				},
+				set callback(newCallback) {
+					currentCallback = newCallback;
+				},
+				setOptions: () => {},
+				get isActive() {
+					return false;
+				}
+			};
+		}
+		const id = generateId();
+		const platform = options.platform ?? this.#platform;
+		const parsedHotkey = typeof hotkey === "string" ? parseHotkey(hotkey, platform) : rawHotkeyToParsedHotkey(hotkey, platform);
+		const hotkeyStr = typeof hotkey === "string" ? hotkey : formatHotkey(parsedHotkey);
+		const target = options.target ?? document;
+		const conflictBehavior = options.conflictBehavior ?? "warn";
+		const conflictingRegistration = this.#findConflictingRegistration(hotkeyStr, target);
+		if (conflictingRegistration) handleConflict(conflictingRegistration.id, hotkeyStr, conflictBehavior, (id) => this.#unregister(id));
+		const resolvedIgnoreInputs = options.ignoreInputs ?? getDefaultIgnoreInputs(parsedHotkey);
+		const registration = {
+			id,
+			hotkey: hotkeyStr,
+			parsedHotkey,
+			callback,
+			options: {
+				...defaultHotkeyOptions,
+				requireReset: false,
+				...options,
+				platform,
+				ignoreInputs: resolvedIgnoreInputs
+			},
+			hasFired: false,
+			triggerCount: 0,
+			target
+		};
+		this.registrations.setState((prev) => new Map(prev).set(id, registration));
+		if (!this.#targetRegistrations.has(target)) this.#targetRegistrations.set(target, /* @__PURE__ */ new Set());
+		this.#targetRegistrations.get(target).add(id);
+		this.#ensureListenersForTarget(target);
+		const manager = this;
+		return {
+			get id() {
+				return id;
+			},
+			unregister: () => {
+				manager.#unregister(id);
+			},
+			get callback() {
+				return manager.registrations.state.get(id)?.callback ?? callback;
+			},
+			set callback(newCallback) {
+				const reg = manager.registrations.state.get(id);
+				if (reg) reg.callback = newCallback;
+			},
+			setOptions: (newOptions) => {
+				manager.registrations.setState((prev) => {
+					const reg = prev.get(id);
+					if (reg) {
+						const next = new Map(prev);
+						next.set(id, {
+							...reg,
+							options: {
+								...reg.options,
+								...newOptions
+							}
+						});
+						return next;
+					}
+					return prev;
+				});
+			},
+			get isActive() {
+				return manager.registrations.state.has(id);
+			}
+		};
+	}
+	/**
+	* Unregisters a hotkey by its registration ID.
+	*/
+	#unregister(id) {
+		const registration = this.registrations.state.get(id);
+		if (!registration) return;
+		const target = registration.target;
+		this.registrations.setState((prev) => {
+			const next = new Map(prev);
+			next.delete(id);
+			return next;
+		});
+		const targetRegs = this.#targetRegistrations.get(target);
+		if (targetRegs) {
+			targetRegs.delete(id);
+			if (targetRegs.size === 0) this.#removeListenersForTarget(target);
+		}
+	}
+	/**
+	* Ensures event listeners are attached for a specific target.
+	*/
+	#ensureListenersForTarget(target) {
+		if (typeof document === "undefined") return;
+		if (this.#targetListeners.has(target)) return;
+		const keydownHandler = this.#createTargetKeyDownHandler(target);
+		const keyupHandler = this.#createTargetKeyUpHandler(target);
+		target.addEventListener("keydown", keydownHandler);
+		target.addEventListener("keyup", keyupHandler);
+		this.#targetListeners.set(target, {
+			keydown: keydownHandler,
+			keyup: keyupHandler
+		});
+	}
+	/**
+	* Removes event listeners for a specific target.
+	*/
+	#removeListenersForTarget(target) {
+		if (typeof document === "undefined") return;
+		const listeners = this.#targetListeners.get(target);
+		if (!listeners) return;
+		target.removeEventListener("keydown", listeners.keydown);
+		target.removeEventListener("keyup", listeners.keyup);
+		this.#targetListeners.delete(target);
+		this.#targetRegistrations.delete(target);
+	}
+	/**
+	* Processes keyboard events for a specific target and event type.
+	*/
+	#processTargetEvent(event, target, eventType) {
+		const targetRegs = this.#targetRegistrations.get(target);
+		if (!targetRegs) return;
+		for (const id of targetRegs) {
+			const registration = this.registrations.state.get(id);
+			if (!registration) continue;
+			if (!isEventForTarget(event, target)) continue;
+			if (!registration.options.enabled) continue;
+			if (registration.options.ignoreInputs !== false) {
+				if (shouldIgnoreInputEvent(event, target, registration.target)) continue;
+			}
+			if (eventType === "keydown") {
+				if (registration.options.eventType !== "keydown") continue;
+				if (matchesKeyboardEvent(event, registration.parsedHotkey, registration.options.platform)) {
+					if (registration.options.preventDefault) event.preventDefault();
+					if (registration.options.stopPropagation) event.stopPropagation();
+					if (!registration.options.requireReset || !registration.hasFired) {
+						this.#executeHotkeyCallback(registration, event);
+						if (registration.options.requireReset) registration.hasFired = true;
+					}
+				}
+			} else {
+				if (registration.options.eventType === "keyup") {
+					if (matchesKeyboardEvent(event, registration.parsedHotkey, registration.options.platform)) this.#executeHotkeyCallback(registration, event);
+				}
+				if (registration.options.requireReset && registration.hasFired) {
+					if (this.#shouldResetRegistration(registration, event)) registration.hasFired = false;
+				}
+			}
+		}
+	}
+	/**
+	* Executes a hotkey callback with proper event handling.
+	*/
+	#executeHotkeyCallback(registration, event) {
+		if (registration.options.preventDefault) event.preventDefault();
+		if (registration.options.stopPropagation) event.stopPropagation();
+		registration.triggerCount++;
+		this.registrations.setState((prev) => new Map(prev));
+		const context = {
+			hotkey: registration.hotkey,
+			parsedHotkey: registration.parsedHotkey
+		};
+		registration.callback(event, context);
+	}
+	/**
+	* Creates a keydown handler for a specific target.
+	*/
+	#createTargetKeyDownHandler(target) {
+		return (event) => {
+			this.#processTargetEvent(event, target, "keydown");
+		};
+	}
+	/**
+	* Creates a keyup handler for a specific target.
+	*/
+	#createTargetKeyUpHandler(target) {
+		return (event) => {
+			this.#processTargetEvent(event, target, "keyup");
+		};
+	}
+	/**
+	* Finds an existing registration with the same hotkey and target.
+	*/
+	#findConflictingRegistration(hotkey, target) {
+		for (const registration of this.registrations.state.values()) if (registration.hotkey === hotkey && registration.target === target) return registration;
+		return null;
+	}
+	/**
+	* Determines if a registration should be reset based on the keyup event.
+	*/
+	#shouldResetRegistration(registration, event) {
+		const parsed = registration.parsedHotkey;
+		const releasedKey = normalizeKeyName(event.key);
+		const parsedKeyNormalized = parsed.key.length === 1 ? parsed.key.toUpperCase() : parsed.key;
+		if ((releasedKey.length === 1 ? releasedKey.toUpperCase() : releasedKey) === parsedKeyNormalized) return true;
+		if (parsed.ctrl && releasedKey === "Control") return true;
+		if (parsed.shift && releasedKey === "Shift") return true;
+		if (parsed.alt && releasedKey === "Alt") return true;
+		if (parsed.meta && releasedKey === "Meta") return true;
+		return false;
+	}
+	/**
+	* Triggers a registration's callback programmatically from devtools.
+	* Creates a synthetic KeyboardEvent and invokes the callback.
+	*
+	* @param id - The registration ID to trigger
+	* @returns True if the registration was found and triggered
+	*/
+	triggerRegistration(id) {
+		const registration = this.registrations.state.get(id);
+		if (!registration) return false;
+		const parsed = registration.parsedHotkey;
+		const syntheticEvent = new KeyboardEvent(registration.options.eventType ?? "keydown", {
+			key: parsed.key,
+			ctrlKey: parsed.ctrl,
+			shiftKey: parsed.shift,
+			altKey: parsed.alt,
+			metaKey: parsed.meta,
+			bubbles: true,
+			cancelable: true
+		});
+		registration.triggerCount++;
+		this.registrations.setState((prev) => new Map(prev));
+		registration.callback(syntheticEvent, {
+			hotkey: registration.hotkey,
+			parsedHotkey: registration.parsedHotkey
+		});
+		return true;
+	}
+	/**
+	* Gets the number of registered hotkeys.
+	*/
+	getRegistrationCount() {
+		return this.registrations.state.size;
+	}
+	/**
+	* Checks if a specific hotkey is registered.
+	*
+	* @param hotkey - The hotkey string to check
+	* @param target - Optional target element to match (if provided, both hotkey and target must match)
+	* @returns True if a matching registration exists
+	*/
+	isRegistered(hotkey, target) {
+		for (const registration of this.registrations.state.values()) if (registration.hotkey === hotkey) {
+			if (target === void 0 || registration.target === target) return true;
+		}
+		return false;
+	}
+	/**
+	* Destroys the manager and removes all listeners.
+	*/
+	destroy() {
+		for (const target of this.#targetListeners.keys()) this.#removeListenersForTarget(target);
+		this.registrations.setState(() => /* @__PURE__ */ new Map());
+		this.#targetListeners.clear();
+		this.#targetRegistrations.clear();
+	}
+};
+/**
+* Gets the singleton HotkeyManager instance.
+* Convenience function for accessing the manager.
+*/
+function getHotkeyManager() {
+	return HotkeyManager.getInstance();
+}
+//#endregion
+export { getHotkeyManager };

package/dist/node_modules/@tanstack/hotkeys/dist/manager.utils.cjs

@@ -0,0 +1,111 @@
+//#region ../../node_modules/@tanstack/hotkeys/dist/manager.utils.js
+/**
+* Default options for hotkey/sequence registration.
+* Omitted: platform, target (resolved at registration), requireReset (HotkeyManager only).
+*/
+var defaultHotkeyOptions = {
+	preventDefault: true,
+	stopPropagation: true,
+	eventType: "keydown",
+	enabled: true,
+	ignoreInputs: true,
+	conflictBehavior: "warn"
+};
+/**
+* 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.
+*/
+function getDefaultIgnoreInputs(parsedHotkey) {
+	if (parsedHotkey.ctrl || parsedHotkey.meta) return false;
+	if (parsedHotkey.key === "Escape") return false;
+	return true;
+}
+/**
+* Checks if an element is an input-like element that should be ignored for hotkeys.
+*
+* This includes:
+* - HTMLInputElement (all input types except button, submit, reset)
+* - HTMLTextAreaElement
+* - HTMLSelectElement
+* - Elements with contentEditable enabled
+*
+* Button-type inputs (button, submit, reset) are excluded so hotkeys like
+* Mod+S and Escape fire when the user has tabbed to a form button.
+*/
+function isInputElement(element) {
+	if (!element) return false;
+	if (element instanceof HTMLInputElement) {
+		const type = element.type.toLowerCase();
+		if (type === "button" || type === "submit" || type === "reset") return false;
+		return true;
+	}
+	if (element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) return true;
+	if (element instanceof HTMLElement && element.isContentEditable) return true;
+	return false;
+}
+/**
+* Returns the focused element for the document associated with where hotkey
+* listeners are attached (listener root). Use this instead of the global
+* `document.activeElement` so registrations scoped to an iframe (or another
+* document) read focus from the correct tree.
+*/
+function getActiveElementForListenerTarget(target) {
+	if (typeof document === "undefined") return null;
+	if (typeof Document !== "undefined" && target instanceof Document || typeof Node !== "undefined" && target.nodeType === Node.DOCUMENT_NODE) return target.activeElement;
+	if (typeof HTMLElement !== "undefined" && target instanceof HTMLElement) return target.ownerDocument.activeElement ?? null;
+	return target.document.activeElement ?? null;
+}
+/**
+* Returns whether an event should be ignored because it originated from an
+* input-like element other than the registration target.
+*
+* This checks:
+* - the currently focused element for the listener target
+* - the event's composed path (for shadow DOM)
+* - the event target as a final fallback
+*/
+function shouldIgnoreInputEvent(event, listenerTarget, registrationTarget) {
+	const focused = getActiveElementForListenerTarget(listenerTarget);
+	if (focused && isInputElement(focused) && focused !== registrationTarget) return true;
+	if (event.composedPath().some((element) => isInputElement(element) && element !== registrationTarget)) return true;
+	return isInputElement(event.target) && event.target !== registrationTarget;
+}
+/**
+* Checks if an event is for the given target (originated from or bubbled to it).
+*
+* For document/window targets, also accepts document.documentElement as currentTarget
+* to handle Brave and other browsers where currentTarget may be documentElement
+* instead of document when listeners are attached to document.
+*/
+function isEventForTarget(event, target) {
+	if (target === document || target === window) return event.currentTarget === target || event.currentTarget === document.documentElement;
+	if (target === window) return event.currentTarget === window || event.currentTarget === document || event.currentTarget === document.documentElement;
+	if (target instanceof HTMLElement) {
+		if (event.currentTarget === target) return true;
+		if (event.target instanceof Node && target.contains(event.target)) return true;
+	}
+	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
+*/
+function handleConflict(conflictingId, keyDisplay, conflictBehavior, unregister) {
+	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.`);
+	unregister(conflictingId);
+}
+//#endregion
+exports.defaultHotkeyOptions = defaultHotkeyOptions;
+exports.getDefaultIgnoreInputs = getDefaultIgnoreInputs;
+exports.handleConflict = handleConflict;
+exports.isEventForTarget = isEventForTarget;
+exports.shouldIgnoreInputEvent = shouldIgnoreInputEvent;

package/dist/node_modules/@tanstack/hotkeys/dist/manager.utils.js

@@ -0,0 +1,107 @@
+//#region ../../node_modules/@tanstack/hotkeys/dist/manager.utils.js
+/**
+* Default options for hotkey/sequence registration.
+* Omitted: platform, target (resolved at registration), requireReset (HotkeyManager only).
+*/
+var defaultHotkeyOptions = {
+	preventDefault: true,
+	stopPropagation: true,
+	eventType: "keydown",
+	enabled: true,
+	ignoreInputs: true,
+	conflictBehavior: "warn"
+};
+/**
+* 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.
+*/
+function getDefaultIgnoreInputs(parsedHotkey) {
+	if (parsedHotkey.ctrl || parsedHotkey.meta) return false;
+	if (parsedHotkey.key === "Escape") return false;
+	return true;
+}
+/**
+* Checks if an element is an input-like element that should be ignored for hotkeys.
+*
+* This includes:
+* - HTMLInputElement (all input types except button, submit, reset)
+* - HTMLTextAreaElement
+* - HTMLSelectElement
+* - Elements with contentEditable enabled
+*
+* Button-type inputs (button, submit, reset) are excluded so hotkeys like
+* Mod+S and Escape fire when the user has tabbed to a form button.
+*/
+function isInputElement(element) {
+	if (!element) return false;
+	if (element instanceof HTMLInputElement) {
+		const type = element.type.toLowerCase();
+		if (type === "button" || type === "submit" || type === "reset") return false;
+		return true;
+	}
+	if (element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) return true;
+	if (element instanceof HTMLElement && element.isContentEditable) return true;
+	return false;
+}
+/**
+* Returns the focused element for the document associated with where hotkey
+* listeners are attached (listener root). Use this instead of the global
+* `document.activeElement` so registrations scoped to an iframe (or another
+* document) read focus from the correct tree.
+*/
+function getActiveElementForListenerTarget(target) {
+	if (typeof document === "undefined") return null;
+	if (typeof Document !== "undefined" && target instanceof Document || typeof Node !== "undefined" && target.nodeType === Node.DOCUMENT_NODE) return target.activeElement;
+	if (typeof HTMLElement !== "undefined" && target instanceof HTMLElement) return target.ownerDocument.activeElement ?? null;
+	return target.document.activeElement ?? null;
+}
+/**
+* Returns whether an event should be ignored because it originated from an
+* input-like element other than the registration target.
+*
+* This checks:
+* - the currently focused element for the listener target
+* - the event's composed path (for shadow DOM)
+* - the event target as a final fallback
+*/
+function shouldIgnoreInputEvent(event, listenerTarget, registrationTarget) {
+	const focused = getActiveElementForListenerTarget(listenerTarget);
+	if (focused && isInputElement(focused) && focused !== registrationTarget) return true;
+	if (event.composedPath().some((element) => isInputElement(element) && element !== registrationTarget)) return true;
+	return isInputElement(event.target) && event.target !== registrationTarget;
+}
+/**
+* Checks if an event is for the given target (originated from or bubbled to it).
+*
+* For document/window targets, also accepts document.documentElement as currentTarget
+* to handle Brave and other browsers where currentTarget may be documentElement
+* instead of document when listeners are attached to document.
+*/
+function isEventForTarget(event, target) {
+	if (target === document || target === window) return event.currentTarget === target || event.currentTarget === document.documentElement;
+	if (target === window) return event.currentTarget === window || event.currentTarget === document || event.currentTarget === document.documentElement;
+	if (target instanceof HTMLElement) {
+		if (event.currentTarget === target) return true;
+		if (event.target instanceof Node && target.contains(event.target)) return true;
+	}
+	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
+*/
+function handleConflict(conflictingId, keyDisplay, conflictBehavior, unregister) {
+	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.`);
+	unregister(conflictingId);
+}
+//#endregion
+export { defaultHotkeyOptions, getDefaultIgnoreInputs, handleConflict, isEventForTarget, shouldIgnoreInputEvent };

package/dist/node_modules/@tanstack/hotkeys/dist/match.cjs

@@ -0,0 +1,59 @@
+const require_constants = require("./constants.cjs");
+const require_parse = require("./parse.cjs");
+//#region ../../node_modules/@tanstack/hotkeys/dist/match.js
+/**
+* Checks if a KeyboardEvent matches a hotkey.
+*
+* Uses the `key` property from KeyboardEvent for matching, with a fallback to `code`
+* for letter keys, digit keys (0-9), and punctuation keys when `key` produces special
+* characters (e.g., macOS Option+letter, Shift+number, or Option+punctuation).
+* Letter keys are matched case-insensitively.
+*
+* Also handles "dead key" events where `event.key` is `'Dead'` instead of the expected
+* character. This commonly occurs on macOS with Option+letter combinations (e.g., Option+E,
+* Option+I, Option+U, Option+N) and on Windows/Linux with international keyboard layouts.
+* In these cases, `event.code` is used to determine the physical key.
+*
+* @param event - The KeyboardEvent to check
+* @param hotkey - The hotkey string or ParsedHotkey to match against
+* @param platform - The target platform for resolving 'Mod' (defaults to auto-detection)
+* @returns True if the event matches the hotkey
+*
+* @example
+* ```ts
+* document.addEventListener('keydown', (event) => {
+*   if (matchesKeyboardEvent(event, 'Mod+S')) {
+*     event.preventDefault()
+*     handleSave()
+*   }
+* })
+* ```
+*/
+function matchesKeyboardEvent(event, hotkey, platform = require_constants.detectPlatform()) {
+	const parsed = typeof hotkey === "string" ? require_parse.parseHotkey(hotkey, platform) : hotkey;
+	if (event.ctrlKey !== parsed.ctrl) return false;
+	if (event.shiftKey !== parsed.shift) return false;
+	if (event.altKey !== parsed.alt) return false;
+	if (event.metaKey !== parsed.meta) return false;
+	const eventKey = require_constants.normalizeKeyName(event.key);
+	const hotkeyKey = parsed.key;
+	if (eventKey !== "Dead" && eventKey.length === 1 && hotkeyKey.length === 1) {
+		if (eventKey.toUpperCase() === hotkeyKey.toUpperCase()) return true;
+		if (require_constants.isSingleLetterKey(eventKey) && (/^[A-Za-z]$/.test(eventKey) || !event.altKey)) return false;
+	}
+	if (event.code && (eventKey === "Dead" || eventKey.length === 1 && hotkeyKey.length === 1)) {
+		if (event.code.startsWith("Key")) {
+			const codeLetter = event.code.slice(3);
+			if (codeLetter.length === 1 && /^[A-Za-z]$/.test(codeLetter)) return codeLetter.toUpperCase() === hotkeyKey.toUpperCase();
+		}
+		if (event.code.startsWith("Digit")) {
+			const codeDigit = event.code.slice(5);
+			if (codeDigit.length === 1 && /^[0-9]$/.test(codeDigit)) return codeDigit === hotkeyKey;
+		}
+		if (event.code in require_constants.PUNCTUATION_CODE_MAP) return require_constants.PUNCTUATION_CODE_MAP[event.code] === hotkeyKey;
+		return false;
+	}
+	return eventKey === hotkeyKey;
+}
+//#endregion
+exports.matchesKeyboardEvent = matchesKeyboardEvent;