@wirekyt/dom 0.0.1 → 0.0.2

package/dist/hotkeys.cjs

@@ -0,0 +1,1183 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/common/hotkeys/modifier.ts
+const MODIFIER_NORMALIZATION_MAP = /* @__PURE__ */ new Map([
+	["ctrl", "Control"],
+	["control", "Control"],
+	["alt", "Alt"],
+	["option", "Alt"],
+	["shift", "Shift"],
+	["meta", "Meta"],
+	["cmd", "Meta"],
+	["command", "Meta"],
+	["win", "Meta"],
+	["windows", "Meta"]
+]);
+const normalizeModifier = (key) => MODIFIER_NORMALIZATION_MAP.get(key.toLowerCase()) ?? key;
+const MODIFIER_SET = /* @__PURE__ */ new Set([
+	"control",
+	"ctrl",
+	"alt",
+	"option",
+	"shift",
+	"meta",
+	"cmd",
+	"command",
+	"win",
+	"windows"
+]);
+const isModifierSet = (key) => MODIFIER_SET.has(key.toLowerCase());
+function resolveControlOrMeta(key, platform) {
+	return isModKey(key.toLowerCase()) ? platform === "mac" ? "Meta" : "Control" : key;
+}
+function isModKey(key) {
+	return key.toLowerCase() === "mod" || key.toLowerCase() === "controlormeta";
+}
+//#endregion
+//#region src/common/hotkeys/normalize.ts
+function normalizeKey(eventKey) {
+	if (eventKey.length === 1 && SINGLE_LETTER_REGEX.test(eventKey)) return eventKey.toUpperCase();
+	const lower = eventKey.toLowerCase();
+	const normalized = KEY_NORMALIZATION_MAP.get(lower);
+	if (normalized !== void 0) return normalized;
+	if (FUNCTION_KEY_REGEX$1.test(lower)) return lower.toUpperCase();
+	return eventKey;
+}
+const SINGLE_LETTER_REGEX = /[a-z]/i;
+const FUNCTION_KEY_REGEX$1 = /^f([1-9]|1[0-9])$/;
+const KEY_NORMALIZATION_MAP = /* @__PURE__ */ new Map([
+	["backspace", "Backspace"],
+	["tab", "Tab"],
+	["clear", "Clear"],
+	["enter", "Enter"],
+	["return", "Enter"],
+	["esc", "Escape"],
+	["escape", "Escape"],
+	["space", " "],
+	["spacebar", " "],
+	["up", "ArrowUp"],
+	["arrowup", "ArrowUp"],
+	["down", "ArrowDown"],
+	["arrowdown", "ArrowDown"],
+	["left", "ArrowLeft"],
+	["arrowleft", "ArrowLeft"],
+	["right", "ArrowRight"],
+	["arrowright", "ArrowRight"],
+	["pageup", "PageUp"],
+	["pgup", "PageUp"],
+	["pagedown", "PageDown"],
+	["pgdn", "PageDown"],
+	["home", "Home"],
+	["end", "End"],
+	["del", "Delete"],
+	["delete", "Delete"],
+	["ins", "Insert"],
+	["insert", "Insert"]
+]);
+//#endregion
+//#region src/common/hotkeys/key-to-code.ts
+function keyToCode(key) {
+	if (UPPERCASE_LETTER_REGEX.test(key)) return `Key${key}`;
+	if (SINGLE_DIGIT_REGEX.test(key)) return `Digit${key}`;
+	if (FUNCTION_KEY_WITH_F20_REGEX.test(key)) return key;
+	if (DIRECT_KEY_CODES.has(key)) return key;
+	return SPECIAL_KEY_CODES.get(key);
+}
+const UPPERCASE_LETTER_REGEX = /^[A-Z]$/;
+const SINGLE_DIGIT_REGEX = /^[0-9]$/;
+const FUNCTION_KEY_WITH_F20_REGEX = /^F([1-9]|1[0-9]|20)$/;
+const DIRECT_KEY_CODES = /* @__PURE__ */ new Set([
+	"Enter",
+	"Tab",
+	"Backspace",
+	"Delete",
+	"Escape",
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown",
+	"Insert"
+]);
+const SPECIAL_KEY_CODES = /* @__PURE__ */ new Map([
+	[" ", "Space"],
+	["-", "Minus"],
+	["=", "Equal"],
+	["+", "Equal"],
+	["[", "BracketLeft"],
+	["]", "BracketRight"],
+	[";", "Semicolon"],
+	["'", "Quote"],
+	["`", "Backquote"],
+	["\\", "Backslash"],
+	[",", "Comma"],
+	[".", "Period"],
+	["/", "Slash"]
+]);
+//#endregion
+//#region src/common/hotkeys/utils.ts
+const typeOf = (value) => Object.prototype.toString.call(value).slice(8, -1);
+const isDocument = (value) => typeOf(value) === "Document";
+function getDoc(root) {
+	return isDocument(root) ? root : root.ownerDocument || document;
+}
+function getWin(root) {
+	return getDoc(root).defaultView || window;
+}
+const FORM_TAGS = /* @__PURE__ */ new Set([
+	"input",
+	"textarea",
+	"select"
+]);
+const isFormTag = (tagName) => FORM_TAGS.has(tagName);
+const isHTMLElement = (target) => {
+	return target !== null && typeof target === "object" && "localName" in target && "nodeType" in target && target.nodeType === 1;
+};
+const getEventTarget = (event) => {
+	const target = event.composedPath?.()[0] || event.target;
+	return isHTMLElement(target) ? target : null;
+};
+const isContentEditableElement = (target) => {
+	if (!target) return false;
+	return isHTMLElement(target) && target.isContentEditable;
+};
+const NA_REGEX = /Mac|iPod|iPhone|iPad/;
+const isMac = () => typeof navigator !== "undefined" && NA_REGEX.test(navigator.userAgent);
+const getPlatform = () => isMac() ? "mac" : "windows";
+const toArray = (value) => {
+	if (Array.isArray(value)) return value.filter((item) => item !== void 0);
+	return value !== void 0 ? [value] : [];
+};
+const UNICODE_LETTER = /^\p{L}$/u;
+const UNICODE_NUMBER = /^\p{N}$/u;
+const isSymbolKey = (key) => {
+	if (key.length !== 1) return false;
+	if (UNICODE_LETTER.test(key) || UNICODE_NUMBER.test(key)) return false;
+	return true;
+};
+//#endregion
+//#region src/common/hotkeys/parser.ts
+function parseHotkeyString(hotkey, platform) {
+	const parts = hotkey.split("+");
+	const modifiers = [];
+	let keyIndex = parts.length - 1;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const part = parts[i].trim().toLowerCase();
+		const resolved = resolveControlOrMeta(part, platform).toLowerCase();
+		if (part === "") {
+			keyIndex = i;
+			break;
+		}
+		if (isModifierSet(resolved) || resolved === "mod" || resolved === "controlormeta") modifiers.push(parts[i].trim());
+		else {
+			keyIndex = i;
+			break;
+		}
+	}
+	return {
+		modifiers,
+		key: parts.slice(keyIndex).join("+").trim()
+	};
+}
+function parseHotkey(hotkey, platform) {
+	if (hotkey.includes(">")) {
+		const sequenceParts = hotkey.split(">");
+		const sequenceSteps = [];
+		const allKeys = [];
+		const allCodes = [];
+		for (const rawPart of sequenceParts) {
+			const part = rawPart.trim();
+			if (part.includes("+")) {
+				const { modifiers, key } = parseHotkeyString(part, platform);
+				const step = {
+					key: normalizeKey(key),
+					alt: false,
+					ctrl: false,
+					meta: false,
+					shift: false
+				};
+				for (const modifier of modifiers) switch (normalizeModifier(resolveControlOrMeta(modifier, platform))) {
+					case "Alt":
+						step.alt = true;
+						break;
+					case "Control":
+						step.ctrl = true;
+						break;
+					case "Meta":
+						step.meta = true;
+						break;
+					case "Shift":
+						step.shift = true;
+						break;
+				}
+				sequenceSteps.push(step);
+				allKeys.push(step.key);
+				const code = keyToCode(step.key);
+				if (code != null) allCodes.push(code);
+			} else {
+				const key = normalizeKey(part);
+				sequenceSteps.push({
+					key,
+					alt: false,
+					ctrl: false,
+					meta: false,
+					shift: false
+				});
+				allKeys.push(key);
+				const code = keyToCode(key);
+				if (code != null) allCodes.push(code);
+			}
+		}
+		return {
+			keys: allKeys,
+			codes: allCodes.length > 0 ? allCodes : void 0,
+			alt: false,
+			ctrl: false,
+			meta: false,
+			shift: false,
+			isSequence: true,
+			sequenceSteps
+		};
+	}
+	const { modifiers, key } = parseHotkeyString(hotkey, platform);
+	const result = {
+		keys: [],
+		codes: [],
+		alt: false,
+		ctrl: false,
+		meta: false,
+		shift: false,
+		isSequence: false
+	};
+	for (const modifier of modifiers) switch (normalizeModifier(resolveControlOrMeta(modifier, platform))) {
+		case "Alt":
+			result.alt = true;
+			break;
+		case "Control":
+			result.ctrl = true;
+			break;
+		case "Meta":
+			result.meta = true;
+			break;
+		case "Shift":
+			result.shift = true;
+			break;
+	}
+	if (key && key !== ">") {
+		const normalizedKey = normalizeKey(key);
+		result.keys.push(normalizedKey);
+		const code = keyToCode(normalizedKey);
+		if (code != null) result.codes?.push(code);
+	}
+	return result;
+}
+function toMatchableHotkeySteps(parsed) {
+	return parsed.keys.map((key, index) => ({
+		key,
+		code: parsed.codes?.[index],
+		alt: parsed.alt,
+		ctrl: parsed.ctrl,
+		meta: parsed.meta,
+		shift: parsed.shift
+	}));
+}
+function matchesHotkeyStep(step, event) {
+	const eventKey = normalizeKey(event.key);
+	const keyMatches = step.key === eventKey;
+	if (isSymbolKey(step.key)) {
+		const modifierHeld = event.altKey || event.metaKey || event.ctrlKey;
+		if (!keyMatches && !(modifierHeld && step.code && step.code === event.code)) return false;
+		const isRealAltGr = (event.getModifierState?.("AltGraph") ?? false) && event.ctrlKey;
+		const effectiveCtrl = isRealAltGr ? false : event.ctrlKey;
+		const effectiveAlt = isRealAltGr ? false : event.altKey;
+		if ((step.ctrl || false) !== effectiveCtrl) return false;
+		if ((step.meta || false) !== event.metaKey) return false;
+		if (step.shift && !event.shiftKey) return false;
+		if (step.alt && !effectiveAlt) return false;
+		return true;
+	}
+	if ((event.getModifierState?.("AltGraph") ?? false) && event.ctrlKey) return false;
+	if ((step.alt || false) !== event.altKey) return false;
+	if ((step.ctrl || false) !== event.ctrlKey) return false;
+	if ((step.meta || false) !== event.metaKey) return false;
+	if ((step.shift || false) !== event.shiftKey) return false;
+	return keyMatches || !!step.code && step.code === event.code;
+}
+function matchesHotkey(parsed, event) {
+	return toMatchableHotkeySteps(parsed).some((step) => matchesHotkeyStep(step, event));
+}
+function shouldTrigger(event, options) {
+	const target = getEventTarget(event);
+	if (!target) return true;
+	const tagName = target.localName;
+	const isContentEditable = isContentEditableElement(target);
+	if (isFormTag(tagName)) {
+		if (options.enableOnFormTags === false || options.enableOnFormTags === void 0) return false;
+		if (Array.isArray(options.enableOnFormTags)) {
+			if (!options.enableOnFormTags.includes(tagName)) return false;
+		}
+	}
+	if (isContentEditable && !options.enableOnContentEditable) return false;
+	return true;
+}
+function isHotKey(hotkey, event, options = {}, platform) {
+	if (event.key === "Dead") return false;
+	if (!shouldTrigger(event, options)) return false;
+	const resolved = platform ?? getPlatform();
+	return toArray(hotkey).some((h) => {
+		return matchesHotkey(parseHotkey(h, resolved), event);
+	});
+}
+function isHotkeyEqual(a, b, platform) {
+	const resolved = platform ?? getPlatform();
+	const pa = parseHotkey(a, resolved);
+	const pb = parseHotkey(b, resolved);
+	if (pa.isSequence !== pb.isSequence) return false;
+	if (pa.isSequence && pb.isSequence) {
+		const stepsA = pa.sequenceSteps;
+		const stepsB = pb.sequenceSteps;
+		if (!stepsA || !stepsB || stepsA.length !== stepsB.length) return false;
+		return stepsA.every((stepA, i) => {
+			const stepB = stepsB[i];
+			return stepA.key === stepB.key && (stepA.ctrl ?? false) === (stepB.ctrl ?? false) && (stepA.alt ?? false) === (stepB.alt ?? false) && (stepA.shift ?? false) === (stepB.shift ?? false) && (stepA.meta ?? false) === (stepB.meta ?? false);
+		});
+	}
+	return pa.ctrl === pb.ctrl && pa.alt === pb.alt && pa.shift === pb.shift && pa.meta === pb.meta && pa.keys.length === pb.keys.length && pa.keys.every((k, i) => k === pb.keys[i]);
+}
+function getHotkeyPriority(parsed) {
+	let priority = 0;
+	if (parsed.isSequence) priority += 1e3;
+	if (parsed.alt) priority += 100;
+	if (parsed.ctrl) priority += 100;
+	if (parsed.meta) priority += 100;
+	if (parsed.shift) priority += 100;
+	priority += parsed.keys.length * 10;
+	return priority;
+}
+//#endregion
+//#region src/common/hotkeys/store.ts
+const defaultOptions = {
+	preventDefault: true,
+	stopPropagation: false,
+	enableOnFormTags: false,
+	enableOnContentEditable: false,
+	capture: true
+};
+const DEFAULT_SCOPES = ["*"];
+function hasNonShiftModifier(parsed) {
+	return !!(parsed.ctrl || parsed.meta || parsed.alt);
+}
+var HotkeyStore = class {
+	state;
+	target;
+	defaultCommandOptions = { ...defaultOptions };
+	commandOptionOverrides = /* @__PURE__ */ new Map();
+	sequenceTimeoutMs = 1e3;
+	conflictBehavior = "warn";
+	sequenceStates = /* @__PURE__ */ new Map();
+	registrationOrder = 0;
+	platform = "mac";
+	listeners = {};
+	firedCommands = /* @__PURE__ */ new Set();
+	hasKeyupCommands = false;
+	subscribers = /* @__PURE__ */ new Set();
+	constructor(options) {
+		const defaultScopes = options?.activeScopes ? toArray(options.activeScopes) : DEFAULT_SCOPES;
+		this.state = {
+			pressedKeys: /* @__PURE__ */ new Set(),
+			pressedCodes: /* @__PURE__ */ new Set(),
+			commands: /* @__PURE__ */ new Map(),
+			listening: false,
+			activeScopes: new Set(defaultScopes)
+		};
+		if (options?.sequenceTimeoutMs !== void 0) this.sequenceTimeoutMs = options.sequenceTimeoutMs;
+		if (options?.conflictBehavior !== void 0) this.conflictBehavior = options.conflictBehavior;
+		this.applyDefaultOptions(options?.defaultOptions);
+	}
+	init(options) {
+		if (!options.target) throw new Error("target is required for initialization");
+		this.applyDefaultOptions(options.defaultOptions);
+		this.target = options.target;
+		this.platform = getPlatform();
+		this.updateParsedHotkeys();
+		this.updateListeners();
+		return this;
+	}
+	destroy() {
+		this.stopListening();
+		this.clear();
+		this.subscribers.clear();
+		this.sequenceStates.clear();
+		this.firedCommands.clear();
+		this.target = void 0;
+		this.registrationOrder = 0;
+	}
+	setScope(scope) {
+		const scopes = toArray(scope);
+		this.state.activeScopes = new Set(scopes);
+		this.clearAllSequences();
+		this.notifySubscribers();
+		return this;
+	}
+	addScope(scope) {
+		this.state.activeScopes.add(scope);
+		this.notifySubscribers();
+		return this;
+	}
+	removeScope(scope) {
+		this.state.activeScopes.delete(scope);
+		this.notifySubscribers();
+		return this;
+	}
+	getActiveScopes() {
+		return [...this.state.activeScopes];
+	}
+	getState() {
+		return this.state;
+	}
+	toggleScope(scope) {
+		if (this.state.activeScopes.has(scope)) this.state.activeScopes.delete(scope);
+		else this.state.activeScopes.add(scope);
+		this.notifySubscribers();
+		return this;
+	}
+	subscribe(selector, callback) {
+		const subscriber = {
+			selector,
+			callback,
+			lastValue: selector(this.state)
+		};
+		this.subscribers.add(subscriber);
+		return () => {
+			this.subscribers.delete(subscriber);
+		};
+	}
+	register(commands) {
+		const commandArray = toArray(commands);
+		for (const command of commandArray) {
+			const scopes = command.scopes ? toArray(command.scopes) : DEFAULT_SCOPES;
+			const parsed = parseHotkey(command.hotkey, this.platform);
+			const priority = getHotkeyPriority(parsed);
+			const resolvedOptions = {
+				...this.defaultCommandOptions,
+				...command.options
+			};
+			if (command.options?.enableOnFormTags === void 0 && hasNonShiftModifier(parsed)) resolvedOptions.enableOnFormTags = true;
+			this.detectConflicts(command.id, command.hotkey);
+			this.state.commands.set(command.id, {
+				id: command.id,
+				hotkey: command.hotkey,
+				action: command.action,
+				options: resolvedOptions,
+				enabled: command.enabled ?? true,
+				scopes,
+				keywords: command.keywords ?? [],
+				_parsed: parsed,
+				_priority: priority,
+				_registrationOrder: this.registrationOrder++,
+				...command.label !== void 0 && { label: command.label },
+				...command.description !== void 0 && { description: command.description },
+				...command.category !== void 0 && { category: command.category }
+			});
+			this.commandOptionOverrides.set(command.id, command.options);
+		}
+		this.refreshKeyupFlag();
+		this.updateListeners();
+		this.notifySubscribers();
+		return this;
+	}
+	unregister(id) {
+		const command = this.state.commands.get(id);
+		if (command) {
+			this.state.commands.delete(id);
+			this.commandOptionOverrides.delete(id);
+			this.firedCommands.delete(id);
+			this.resetSequence(command.hotkey);
+			this.refreshKeyupFlag();
+			this.updateListeners();
+			this.notifySubscribers();
+		}
+		return this;
+	}
+	enable(id) {
+		const command = this.state.commands.get(id);
+		if (command) {
+			command.enabled = true;
+			this.updateListeners();
+			this.notifySubscribers();
+		}
+		return this;
+	}
+	disable(id) {
+		const command = this.state.commands.get(id);
+		if (command) {
+			command.enabled = false;
+			this.updateListeners();
+			this.notifySubscribers();
+		}
+		return this;
+	}
+	setEnabled(id, enabled) {
+		const command = this.state.commands.get(id);
+		if (command) {
+			command.enabled = enabled;
+			this.updateListeners();
+			this.notifySubscribers();
+		}
+		return this;
+	}
+	clear() {
+		this.clearAllSequences();
+		this.state.commands.clear();
+		this.commandOptionOverrides.clear();
+		this.state.pressedKeys.clear();
+		this.state.pressedCodes.clear();
+		this.firedCommands.clear();
+		this.hasKeyupCommands = false;
+		this.updateListeners();
+		this.notifySubscribers();
+		return this;
+	}
+	isPressed(hotkey) {
+		const parsed = parseHotkey(hotkey, this.platform);
+		if (parsed.isSequence) return false;
+		const logicalKeysMatch = parsed.keys.every((k) => this.state.pressedKeys.has(k));
+		const codes = parsed.codes;
+		const codesAligned = codes && codes.length > 0 && codes.length === parsed.keys.length && codes.every((c) => this.state.pressedCodes.has(c));
+		return (logicalKeysMatch || !!codesAligned) && this.modifiersMatchPressed(parsed);
+	}
+	getCurrentlyPressed() {
+		return [...this.state.pressedKeys];
+	}
+	getPressedCodes() {
+		return [...this.state.pressedCodes];
+	}
+	modifiersMatchPressed(parsed) {
+		const pk = this.state.pressedKeys;
+		const has = (name) => pk.has(name);
+		if (parsed.keys.some(isSymbolKey)) {
+			if (parsed.ctrl !== has("Control")) return false;
+			if (parsed.meta !== has("Meta")) return false;
+			if (parsed.shift && !has("Shift")) return false;
+			if (parsed.alt && !has("Alt")) return false;
+			return true;
+		}
+		if (parsed.alt !== has("Alt")) return false;
+		if (parsed.ctrl !== has("Control")) return false;
+		if (parsed.meta !== has("Meta")) return false;
+		if (parsed.shift !== has("Shift")) return false;
+		return true;
+	}
+	applyDefaultOptions(options) {
+		if (!options) return;
+		this.defaultCommandOptions = {
+			...defaultOptions,
+			...options
+		};
+		for (const [id, command] of this.state.commands) command.options = {
+			...this.defaultCommandOptions,
+			...this.commandOptionOverrides.get(id)
+		};
+	}
+	updateParsedHotkeys() {
+		for (const command of this.state.commands.values()) if (command.hotkey.split("+").some((part) => isModKey(part.trim()))) {
+			command._parsed = parseHotkey(command.hotkey, this.platform);
+			command._priority = getHotkeyPriority(command._parsed);
+		}
+	}
+	refreshKeyupFlag() {
+		this.hasKeyupCommands = false;
+		for (const command of this.state.commands.values()) if (command.options.eventType === "keyup") {
+			this.hasKeyupCommands = true;
+			break;
+		}
+	}
+	detectConflicts(newId, newHotkey) {
+		if (this.conflictBehavior === "allow") return;
+		const toDelete = [];
+		for (const [existingId, existing] of this.state.commands) {
+			if (existingId === newId) continue;
+			if (existing.hotkey !== newHotkey) continue;
+			const message = `[hotkeys] Conflict: "${newHotkey}" is already registered by command "${existingId}". Command "${newId}" will also respond to this hotkey.`;
+			switch (this.conflictBehavior) {
+				case "error": throw new Error(message);
+				case "replace":
+					toDelete.push(existingId);
+					break;
+				default:
+					console.warn(message);
+					break;
+			}
+		}
+		for (const id of toDelete) {
+			this.state.commands.delete(id);
+			this.commandOptionOverrides.delete(id);
+		}
+	}
+	updateListeners() {
+		if (!this.target) return;
+		if (this.state.commands.size > 0) this.startListening();
+		else this.stopListening();
+	}
+	startListening() {
+		if (!this.target || this.state.listening) return;
+		const win = getWin(this.target);
+		const phases = this.getListenerPhases();
+		if (phases.capture) {
+			const record = {
+				keyDown: ((e) => this.executeMatchingCommands(e, true, "keydown")),
+				keyUp: ((e) => this.handleKeyUp(e, true)),
+				blur: (() => this.handleBlur())
+			};
+			this.target.addEventListener("keydown", record.keyDown, true);
+			this.target.addEventListener("keyup", record.keyUp, true);
+			win.addEventListener("blur", record.blur);
+			win.addEventListener("contextmenu", record.blur);
+			this.listeners.capture = record;
+		}
+		if (phases.bubble) {
+			const record = {
+				keyDown: ((e) => this.executeMatchingCommands(e, false, "keydown")),
+				keyUp: ((e) => this.handleKeyUp(e, false)),
+				blur: (() => this.handleBlur())
+			};
+			this.target.addEventListener("keydown", record.keyDown, false);
+			this.target.addEventListener("keyup", record.keyUp, false);
+			win.addEventListener("blur", record.blur);
+			win.addEventListener("contextmenu", record.blur);
+			this.listeners.bubble = record;
+		}
+		this.state.listening = true;
+	}
+	stopListening() {
+		if (!this.target || !this.state.listening) return;
+		const win = getWin(this.target);
+		if (this.listeners.capture) {
+			const r = this.listeners.capture;
+			if (r.keyDown) this.target.removeEventListener("keydown", r.keyDown, true);
+			if (r.keyUp) this.target.removeEventListener("keyup", r.keyUp, true);
+			if (r.blur) {
+				win.removeEventListener("blur", r.blur);
+				win.removeEventListener("contextmenu", r.blur);
+			}
+		}
+		if (this.listeners.bubble) {
+			const r = this.listeners.bubble;
+			if (r.keyDown) this.target.removeEventListener("keydown", r.keyDown, false);
+			if (r.keyUp) this.target.removeEventListener("keyup", r.keyUp, false);
+			if (r.blur) {
+				win.removeEventListener("blur", r.blur);
+				win.removeEventListener("contextmenu", r.blur);
+			}
+		}
+		this.listeners = {};
+		this.state.listening = false;
+	}
+	getListenerPhases() {
+		let capture = false;
+		let bubble = false;
+		for (const command of this.state.commands.values()) {
+			if (!(typeof command.enabled === "function" ? command.enabled() : command.enabled)) continue;
+			if (command.options.capture !== false) capture = true;
+			else bubble = true;
+			if (capture && bubble) break;
+		}
+		return {
+			capture,
+			bubble
+		};
+	}
+	handleKeyUp(event, capture) {
+		if (this.hasKeyupCommands) this.executeMatchingCommands(event, capture, "keyup");
+		const eventKey = normalizeKey(event.key);
+		this.state.pressedKeys.delete(eventKey);
+		if (event.code) this.state.pressedCodes.delete(event.code);
+		if (this.firedCommands.size > 0) this.firedCommands.clear();
+		this.notifySubscribers();
+	}
+	handleBlur() {
+		this.state.pressedKeys.clear();
+		this.state.pressedCodes.clear();
+		this.firedCommands.clear();
+		this.clearAllSequences();
+		this.notifySubscribers();
+	}
+	executeMatchingCommands(event, capture, eventType) {
+		if (event.key === "Dead") return;
+		const eventKey = normalizeKey(event.key);
+		if (eventType === "keydown") {
+			this.state.pressedKeys.add(eventKey);
+			if (event.code) this.state.pressedCodes.add(event.code);
+			this.notifySubscribers();
+		}
+		const matches = [];
+		for (const [_id, command] of this.state.commands) {
+			if (!(typeof command.enabled === "function" ? command.enabled() : command.enabled)) continue;
+			if (command.options.capture !== false !== capture) continue;
+			if ((command.options.eventType ?? "keydown") !== eventType) continue;
+			if (!command.scopes.some((scope) => scope === "*" || this.state.activeScopes.has(scope))) continue;
+			if (!shouldTrigger(event, command.options)) continue;
+			if (command.options.requireReset && this.firedCommands.has(command.id)) continue;
+			if (command._parsed.isSequence ? this.handleSequence(command.hotkey, command._parsed, eventKey, event) : matchesHotkey(command._parsed, event)) matches.push({
+				command,
+				priority: command._priority
+			});
+		}
+		if (matches.length === 0) return;
+		matches.sort((a, b) => {
+			if (b.priority !== a.priority) return b.priority - a.priority;
+			return a.command._registrationOrder - b.command._registrationOrder;
+		});
+		const highestPriority = matches[0].priority;
+		const toExecute = matches.filter((m) => m.priority === highestPriority);
+		for (const { command } of toExecute) {
+			if (command.options.preventDefault) event.preventDefault();
+			if (command.options.stopPropagation) event.stopPropagation();
+			if (command.options.requireReset) this.firedCommands.add(command.id);
+			try {
+				command.action(event);
+			} catch (error) {
+				console.error(`Error executing hotkey command "${command.id}":`, error);
+			}
+		}
+	}
+	handleSequence(hotkeyString, parsed, eventKey, event) {
+		if (!this.target) {
+			console.warn("Cannot handle sequence: target is not initialized");
+			return false;
+		}
+		const win = getWin(this.target);
+		let state = this.sequenceStates.get(hotkeyString);
+		if (!state) {
+			state = { recordedKeys: [] };
+			this.sequenceStates.set(hotkeyString, state);
+		}
+		if (state.timeoutId) clearTimeout(state.timeoutId);
+		const currentStepIndex = state.recordedKeys.length;
+		const expectedStep = parsed.sequenceSteps?.[currentStepIndex];
+		if (expectedStep) if (matchesHotkeyStep({
+			key: expectedStep.key,
+			code: parsed.codes?.[currentStepIndex],
+			alt: expectedStep.alt,
+			ctrl: expectedStep.ctrl,
+			meta: expectedStep.meta,
+			shift: expectedStep.shift
+		}, event)) {
+			state.recordedKeys.push(eventKey);
+			if (state.recordedKeys.length === parsed.sequenceSteps.length) {
+				this.resetSequence(hotkeyString);
+				return true;
+			}
+			state.timeoutId = win.setTimeout(() => {
+				this.resetSequence(hotkeyString);
+			}, this.sequenceTimeoutMs);
+		} else this.resetSequence(hotkeyString);
+		else this.resetSequence(hotkeyString);
+		return false;
+	}
+	clearAllSequences() {
+		for (const state of this.sequenceStates.values()) if (typeof state.timeoutId === "number") clearTimeout(state.timeoutId);
+		this.sequenceStates.clear();
+	}
+	resetSequence(hotkey) {
+		const state = this.sequenceStates.get(hotkey);
+		if (state && typeof state.timeoutId === "number") clearTimeout(state.timeoutId);
+		this.sequenceStates.delete(hotkey);
+	}
+	notifySubscribers() {
+		for (const subscriber of this.subscribers) try {
+			const newValue = subscriber.selector(this.state);
+			if (newValue !== subscriber.lastValue) {
+				subscriber.lastValue = newValue;
+				subscriber.callback(newValue);
+			}
+		} catch (error) {
+			console.error("Error in hotkey store subscriber:", error);
+		}
+	}
+};
+function createHotkeyStore(options) {
+	const store = new HotkeyStore(options);
+	if (options?.target) store.init(options);
+	return store;
+}
+//#endregion
+//#region src/common/hotkeys/format.ts
+const PLATFORM_MODIFIERS = {
+	mac: {
+		Control: "⌃",
+		Alt: "⌥",
+		Shift: "⇧",
+		Meta: "⌘"
+	},
+	windows: {
+		Control: "Ctrl",
+		Alt: "Alt",
+		Shift: "Shift",
+		Meta: "Win"
+	},
+	linux: {
+		Control: "Ctrl",
+		Alt: "Alt",
+		Shift: "Shift",
+		Meta: "Super"
+	}
+};
+const KEY_SYMBOLS = /* @__PURE__ */ new Map([
+	["ArrowUp", "↑"],
+	["ArrowDown", "↓"],
+	["ArrowLeft", "←"],
+	["ArrowRight", "→"],
+	["Backspace", "⌫"],
+	["Delete", "⌦"],
+	["Enter", "↵"],
+	["Tab", "⇥"],
+	["Escape", "Esc"],
+	["Space", "␣"],
+	[" ", "␣"]
+]);
+const KEY_NAMES = /* @__PURE__ */ new Map([
+	["ArrowUp", "Up"],
+	["ArrowDown", "Down"],
+	["ArrowLeft", "Left"],
+	["ArrowRight", "Right"],
+	["Space", "Space"],
+	[" ", "Space"]
+]);
+function formatHotkey(hotkey, options = {}) {
+	const { platform = "auto", style = "mixed", separator = " ", sequenceSeparator = " then ", useShortNames = true } = options;
+	const targetPlatform = platform === "auto" ? getPlatform() : platform;
+	if (hotkey.includes(">")) return hotkey.split(">").map((part) => formatSingleHotkey(part.trim(), targetPlatform, style, separator, useShortNames)).join(sequenceSeparator);
+	return formatSingleHotkey(hotkey, targetPlatform, style, separator, useShortNames);
+}
+function formatSingleHotkey(hotkey, platform, style, separator, useShortNames) {
+	if (!hotkey.trim()) return "";
+	const parsed = parseHotkey(hotkey, platform);
+	const modifiers = [];
+	if (parsed.ctrl) modifiers.push("Control");
+	if (parsed.alt) modifiers.push("Alt");
+	if (parsed.shift) modifiers.push("Shift");
+	if (parsed.meta) modifiers.push("Meta");
+	const keys = parsed.keys;
+	const platformModifiers = PLATFORM_MODIFIERS[platform];
+	const formattedModifiers = modifiers.map((modifier) => {
+		const mappedModifier = platformModifiers[modifier];
+		if (style === "symbols" && platform === "mac") return mappedModifier || modifier;
+		if (style === "text" || platform !== "mac") return useShortNames && modifier === "Control" ? "Ctrl" : mappedModifier || modifier;
+		return mappedModifier || modifier;
+	});
+	const formattedKeys = keys.map((key) => {
+		if (style === "symbols") return KEY_SYMBOLS.get(key) || key;
+		if (style === "text") return KEY_NAMES.get(key) || key;
+		return KEY_SYMBOLS.get(key) || KEY_NAMES.get(key) || key;
+	});
+	return [...formattedModifiers, ...formattedKeys].join(separator);
+}
+//#endregion
+//#region src/common/hotkeys/recorder.ts
+const MODIFIER_KEYS = /* @__PURE__ */ new Set([
+	"Control",
+	"Alt",
+	"Shift",
+	"Meta"
+]);
+const DEFAULT_SEQUENCE_TIMEOUT = 1e3;
+var HotkeyRecorder = class {
+	state = {
+		recording: false,
+		value: null
+	};
+	target;
+	options;
+	platform;
+	keyDownHandler;
+	keyUpHandler;
+	subscribers = /* @__PURE__ */ new Set();
+	steps = [];
+	sequenceTimerId;
+	constructor(options = {}) {
+		this.options = options;
+		this.platform = getPlatform();
+	}
+	init(target) {
+		this.target = target;
+		this.platform = getPlatform();
+		return this;
+	}
+	start() {
+		if (this.state.recording) return this;
+		const root = this.target;
+		if (!root) {
+			console.warn("HotkeyRecorder: target is not set. Call init() first.");
+			return this;
+		}
+		this.steps = [];
+		this.clearSequenceTimer();
+		this.setState({
+			recording: true,
+			value: this.state.value
+		});
+		this.attachListeners(root);
+		return this;
+	}
+	stop() {
+		if (!this.state.recording) return this;
+		this.finalize();
+		return this;
+	}
+	cancel() {
+		if (!this.state.recording) return this;
+		this.detachListeners();
+		this.clearSequenceTimer();
+		this.steps = [];
+		this.setState({
+			recording: false,
+			value: this.state.value
+		});
+		this.options.onCancel?.();
+		return this;
+	}
+	clear() {
+		this.detachListeners();
+		this.clearSequenceTimer();
+		this.steps = [];
+		this.setState({
+			recording: false,
+			value: null
+		});
+		this.options.onClear?.();
+		return this;
+	}
+	setOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return this;
+	}
+	getState() {
+		return this.state;
+	}
+	subscribe(callback) {
+		this.subscribers.add(callback);
+		return () => {
+			this.subscribers.delete(callback);
+		};
+	}
+	destroy() {
+		this.detachListeners();
+		this.clearSequenceTimer();
+		this.subscribers.clear();
+		this.steps = [];
+		this.target = void 0;
+	}
+	setState(next) {
+		this.state = next;
+		for (const fn of this.subscribers) try {
+			fn(this.state);
+		} catch (error) {
+			console.error("Error in hotkey recorder subscriber:", error);
+		}
+	}
+	attachListeners(root) {
+		this.keyDownHandler = ((event) => {
+			this.handleKeyDown(event);
+		});
+		this.keyUpHandler = ((event) => {
+			event.preventDefault();
+		});
+		root.addEventListener("keydown", this.keyDownHandler, true);
+		root.addEventListener("keyup", this.keyUpHandler, true);
+	}
+	detachListeners() {
+		if (!this.target) return;
+		if (this.keyDownHandler) this.target.removeEventListener("keydown", this.keyDownHandler, true);
+		if (this.keyUpHandler) this.target.removeEventListener("keyup", this.keyUpHandler, true);
+		this.keyDownHandler = void 0;
+		this.keyUpHandler = void 0;
+	}
+	handleKeyDown(event) {
+		event.preventDefault();
+		event.stopPropagation();
+		const key = event.key;
+		if (key === "Escape") {
+			this.cancel();
+			return;
+		}
+		if (key === "Backspace" || key === "Delete") {
+			this.clear();
+			return;
+		}
+		if (MODIFIER_KEYS.has(key)) return;
+		if (key === "Dead") return;
+		this.clearSequenceTimer();
+		const parts = [];
+		if (event.ctrlKey) parts.push("Control");
+		if (event.altKey) parts.push("Alt");
+		if (event.shiftKey) parts.push("Shift");
+		if (event.metaKey) parts.push("Meta");
+		const normalizedKey = normalizeKey(key);
+		parts.push(normalizedKey);
+		const chord = parts.join("+");
+		this.steps.push(chord);
+		const currentValue = this.buildRecordedHotkey();
+		this.setState({
+			recording: true,
+			value: currentValue
+		});
+		const timeout = this.options.sequenceTimeoutMs ?? DEFAULT_SEQUENCE_TIMEOUT;
+		this.sequenceTimerId = setTimeout(() => {
+			this.finalize();
+		}, timeout);
+	}
+	buildRecordedHotkey() {
+		const value = this.steps.join(` > `);
+		return {
+			value,
+			display: formatHotkey(value, {
+				platform: this.platform,
+				...this.options.formatOptions
+			})
+		};
+	}
+	finalize() {
+		this.detachListeners();
+		this.clearSequenceTimer();
+		const recorded = this.steps.length > 0 ? this.buildRecordedHotkey() : null;
+		this.steps = [];
+		this.setState({
+			recording: false,
+			value: recorded
+		});
+		if (recorded) this.options.onRecord?.(recorded);
+	}
+	clearSequenceTimer() {
+		if (this.sequenceTimerId !== void 0) {
+			clearTimeout(this.sequenceTimerId);
+			this.sequenceTimerId = void 0;
+		}
+	}
+};
+function createHotkeyRecorder(options) {
+	const recorder = new HotkeyRecorder(options);
+	if (options?.target) recorder.init(options.target);
+	return recorder;
+}
+//#endregion
+//#region src/common/hotkeys/validate.ts
+const KNOWN_SPECIAL_KEYS = /* @__PURE__ */ new Set([
+	"Backspace",
+	"Tab",
+	"Clear",
+	"Enter",
+	"Escape",
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"PageUp",
+	"PageDown",
+	"Home",
+	"End",
+	"Delete",
+	"Insert",
+	" "
+]);
+const FUNCTION_KEY_REGEX = /^F([1-9]|1[0-9]|20)$/;
+function isKnownKey(key) {
+	if (key.length === 1) return true;
+	if (FUNCTION_KEY_REGEX.test(key)) return true;
+	if (KNOWN_SPECIAL_KEYS.has(key)) return true;
+	if (normalizeKey(key) !== key) return true;
+	return false;
+}
+function validateHotkey(hotkey) {
+	const errors = [];
+	const warnings = [];
+	if (!hotkey || !hotkey.trim()) {
+		errors.push("Hotkey string is empty");
+		return {
+			valid: false,
+			errors,
+			warnings
+		};
+	}
+	if (hotkey.includes(">")) {
+		const steps = hotkey.split(">");
+		for (let i = 0; i < steps.length; i++) {
+			const step = steps[i].trim();
+			if (!step) {
+				errors.push(`Sequence step ${i + 1} is empty`);
+				continue;
+			}
+			const stepResult = validateSingleHotkey(step);
+			for (const err of stepResult.errors) errors.push(`Step ${i + 1}: ${err}`);
+			for (const warn of stepResult.warnings) warnings.push(`Step ${i + 1}: ${warn}`);
+		}
+	} else {
+		const result = validateSingleHotkey(hotkey);
+		errors.push(...result.errors);
+		warnings.push(...result.warnings);
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+function validateSingleHotkey(hotkey) {
+	const errors = [];
+	const warnings = [];
+	const parts = hotkey.split("+");
+	if (parts.length === 0) {
+		errors.push("Hotkey string is empty");
+		return {
+			errors,
+			warnings
+		};
+	}
+	const modifiers = [];
+	let keyPart;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i].trim();
+		if (i === parts.length - 1) if (isModifierSet(part) || part.toLowerCase() === "mod" || part.toLowerCase() === "controlormeta") {
+			warnings.push(`"${hotkey}" contains only modifiers with no action key`);
+			keyPart = part;
+		} else keyPart = part;
+		else if (!isModifierSet(part) && part.toLowerCase() !== "mod" && part.toLowerCase() !== "controlormeta") {
+			if (part === "") {
+				keyPart = "+";
+				break;
+			}
+			errors.push(`"${part}" is not a recognized modifier`);
+		} else {
+			const lower = part.toLowerCase();
+			if (modifiers.includes(lower)) warnings.push(`Duplicate modifier "${part}"`);
+			modifiers.push(lower);
+		}
+	}
+	if (keyPart !== void 0) {
+		if (!isKnownKey(normalizeKey(keyPart)) && keyPart !== "+") warnings.push(`"${keyPart}" is not a commonly recognized key`);
+	}
+	return {
+		errors,
+		warnings
+	};
+}
+function assertValidHotkey(hotkey) {
+	const result = validateHotkey(hotkey);
+	if (!result.valid) throw new Error(`Invalid hotkey "${hotkey}": ${result.errors.join(", ")}`);
+}
+//#endregion
+exports.HotkeyRecorder = HotkeyRecorder;
+exports.HotkeyStore = HotkeyStore;
+exports.assertValidHotkey = assertValidHotkey;
+exports.createHotkeyRecorder = createHotkeyRecorder;
+exports.createHotkeyStore = createHotkeyStore;
+exports.formatHotkey = formatHotkey;
+exports.isHotKey = isHotKey;
+exports.isHotkeyEqual = isHotkeyEqual;
+exports.parseHotkey = parseHotkey;
+exports.validateHotkey = validateHotkey;