@sprawlify/primitives 0.0.1

package/dist/hotkeys.cjs

@@ -0,0 +1,758 @@
+const require_defineProperty = require('./defineProperty-BoUOT9Ie.cjs');
+
+//#region src/shared/hotkeys/modifier.ts
+const MODIFIER_NORMALIZATION_MAP = 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 = 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/shared/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.test(lower)) return lower.toUpperCase();
+	return eventKey;
+}
+const SINGLE_LETTER_REGEX = /[a-z]/i;
+const FUNCTION_KEY_REGEX = /^f([1-9]|1[0-9])$/;
+const KEY_NORMALIZATION_MAP = 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/shared/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 = new Set([
+	"Enter",
+	"Tab",
+	"Backspace",
+	"Delete",
+	"Escape",
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown",
+	"Insert"
+]);
+const SPECIAL_KEY_CODES = new Map([
+	[" ", "Space"],
+	["-", "Minus"],
+	["=", "Equal"],
+	["+", "Equal"],
+	["[", "BracketLeft"],
+	["]", "BracketRight"],
+	[";", "Semicolon"],
+	["'", "Quote"],
+	["`", "Backquote"],
+	["\\", "Backslash"],
+	[",", "Comma"],
+	[".", "Period"],
+	["/", "Slash"]
+]);
+
+//#endregion
+//#region src/shared/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 = new Set([
+	"input",
+	"textarea",
+	"select"
+]);
+const isFormTag = (tagName) => FORM_TAGS.has(tagName);
+const MODIFIER_SEPARATOR = "+";
+const SEQUENCE_SEPARATOR = ">";
+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 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] : [];
+};
+
+//#endregion
+//#region src/shared/hotkeys/parser.ts
+function parseHotkeyString(hotkey, platform) {
+	const parts = hotkey.split(MODIFIER_SEPARATOR);
+	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(MODIFIER_SEPARATOR).trim()
+	};
+}
+function parseHotkey(hotkey, platform) {
+	if (hotkey.includes(SEQUENCE_SEPARATOR)) {
+		const sequenceParts = hotkey.split(SEQUENCE_SEPARATOR);
+		const sequenceSteps = [];
+		const allKeys = [];
+		const allCodes = [];
+		for (const rawPart of sequenceParts) {
+			const part = rawPart.trim();
+			if (part.includes(MODIFIER_SEPARATOR)) {
+				const { modifiers: modifiers$1, key: key$1 } = parseHotkeyString(part, platform);
+				const step = {
+					key: normalizeKey(key$1),
+					alt: false,
+					ctrl: false,
+					meta: false,
+					shift: false
+				};
+				for (const modifier of modifiers$1) 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$1 = normalizeKey(part);
+				sequenceSteps.push({
+					key: key$1,
+					alt: false,
+					ctrl: false,
+					meta: false,
+					shift: false
+				});
+				allKeys.push(key$1);
+				const code = keyToCode(key$1);
+				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 !== SEQUENCE_SEPARATOR) {
+		const normalizedKey = normalizeKey(key);
+		result.keys.push(normalizedKey);
+		const code = keyToCode(normalizedKey);
+		if (code != null) result.codes?.push(code);
+	}
+	return result;
+}
+function matchesHotkey(parsed, event) {
+	if (parsed.alt !== event.altKey) return false;
+	if (parsed.ctrl !== event.ctrlKey) return false;
+	if (parsed.meta !== event.metaKey) return false;
+	if (parsed.shift !== event.shiftKey) return false;
+	const eventKey = normalizeKey(event.key);
+	const eventCode = event.code;
+	const keyMatches = parsed.keys.some((key) => key === eventKey);
+	const codeMatches = parsed.codes ? parsed.codes.some((code) => code === eventCode) : false;
+	return keyMatches || codeMatches;
+}
+function shouldTrigger(event, options) {
+	const target = getEventTarget(event);
+	if (!target) return true;
+	const tagName = target.localName;
+	const isContentEditable = target.getAttribute("contenteditable") === "true";
+	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 = {}) {
+	if (!shouldTrigger(event, options)) return false;
+	const platform = getPlatform();
+	return toArray(hotkey).some((h) => {
+		return matchesHotkey(parseHotkey(h, platform), event);
+	});
+}
+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/shared/hotkeys/store.ts
+const defaultOptions = {
+	preventDefault: true,
+	stopPropagation: false,
+	enableOnFormTags: false,
+	enableOnContentEditable: false,
+	capture: true
+};
+const DEFAULT_SCOPES = ["*"];
+var HotkeyStore = class {
+	constructor(options) {
+		require_defineProperty._defineProperty(this, "state", void 0);
+		require_defineProperty._defineProperty(this, "context", {});
+		require_defineProperty._defineProperty(this, "rootNode", void 0);
+		require_defineProperty._defineProperty(this, "sequenceTimeoutMs", 1e3);
+		require_defineProperty._defineProperty(this, "sequenceStates", /* @__PURE__ */ new Map());
+		require_defineProperty._defineProperty(this, "registrationOrder", 0);
+		require_defineProperty._defineProperty(this, "platform", "mac");
+		require_defineProperty._defineProperty(this, "listeners", {
+			capture: {},
+			bubble: {}
+		});
+		require_defineProperty._defineProperty(this, "subscribers", /* @__PURE__ */ new Set());
+		const defaultScopes = options?.activeScopes ? toArray(options.activeScopes) : DEFAULT_SCOPES;
+		this.state = {
+			pressedKeys: /* @__PURE__ */ new Set(),
+			commands: /* @__PURE__ */ new Map(),
+			listening: false,
+			activeScopes: new Set(defaultScopes)
+		};
+		if (options?.sequenceTimeoutMs !== void 0) this.sequenceTimeoutMs = options.sequenceTimeoutMs;
+	}
+	init(options) {
+		if (!options.rootNode) throw new Error("rootNode is required for initialization");
+		this.rootNode = options.rootNode;
+		this.context = options.context ?? {};
+		this.platform = getPlatform();
+		this.updateParsedHotkeys();
+		this.updateListeners();
+		return this;
+	}
+	destroy() {
+		this.stopListening();
+		this.clear();
+		this.subscribers.clear();
+		this.sequenceStates.clear();
+		this.rootNode = void 0;
+		this.registrationOrder = 0;
+	}
+	setContext(context) {
+		this.context = context;
+		this.notifySubscribers();
+		return this;
+	}
+	getContext() {
+		return this.context;
+	}
+	setScope(scope) {
+		const scopes = toArray(scope);
+		this.state.activeScopes = new Set(scopes);
+		this.sequenceStates.clear();
+		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.context)
+		};
+		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);
+			this.state.commands.set(command.id, {
+				id: command.id,
+				hotkey: command.hotkey,
+				action: command.action,
+				options: {
+					...defaultOptions,
+					...command.options
+				},
+				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.updateListeners();
+		this.notifySubscribers();
+		return this;
+	}
+	unregister(id) {
+		const command = this.state.commands.get(id);
+		if (command) {
+			this.state.commands.delete(id);
+			this.resetSequence(command.hotkey);
+			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() {
+		for (const hotkey of this.sequenceStates.keys()) this.resetSequence(hotkey);
+		this.state.commands.clear();
+		this.updateListeners();
+		this.notifySubscribers();
+		return this;
+	}
+	isPressed(hotkey) {
+		let cachedCommand;
+		for (const cmd of this.state.commands.values()) if (cmd.hotkey === hotkey) {
+			cachedCommand = cmd;
+			break;
+		}
+		const parsed = cachedCommand?._parsed ?? parseHotkey(hotkey, this.platform);
+		const keysMatch = parsed.keys.every((k) => this.state.pressedKeys.has(k));
+		const modifiersMatch = (!parsed.alt || this.state.pressedKeys.has("Alt")) && (!parsed.ctrl || this.state.pressedKeys.has("Control")) && (!parsed.meta || this.state.pressedKeys.has("Meta")) && (!parsed.shift || this.state.pressedKeys.has("Shift"));
+		return keysMatch && modifiersMatch;
+	}
+	getCurrentlyPressed() {
+		return [...this.state.pressedKeys];
+	}
+	updateParsedHotkeys() {
+		for (const command of this.state.commands.values()) if (command.hotkey.split(MODIFIER_SEPARATOR).some((part) => isModKey(part.trim()))) {
+			const parsed = parseHotkey(command.hotkey, this.platform);
+			command._parsed = parsed;
+			command._priority = getHotkeyPriority(parsed);
+		}
+	}
+	updateListeners() {
+		if (!this.rootNode) return;
+		if (this.state.commands.size > 0) this.startListening();
+		else this.stopListening();
+	}
+	startListening() {
+		if (!this.rootNode || this.state.listening) return;
+		const win = getWin(this.rootNode);
+		const captureKeyDownHandler = this.createKeyDownHandler(true);
+		const captureKeyUpHandler = this.createKeyUpHandler();
+		const captureBlurHandler = this.createBlurHandler();
+		const bubbleKeyDownHandler = this.createKeyDownHandler(false);
+		const bubbleKeyUpHandler = this.createKeyUpHandler();
+		const bubbleBlurHandler = this.createBlurHandler();
+		this.listeners.capture.keyDown = captureKeyDownHandler;
+		this.listeners.capture.keyUp = captureKeyUpHandler;
+		this.listeners.capture.blur = captureBlurHandler;
+		this.listeners.bubble.keyDown = bubbleKeyDownHandler;
+		this.listeners.bubble.keyUp = bubbleKeyUpHandler;
+		this.listeners.bubble.blur = bubbleBlurHandler;
+		const phases = this.getListenerPhases();
+		if (phases.capture) {
+			this.rootNode.addEventListener("keydown", captureKeyDownHandler, true);
+			this.rootNode.addEventListener("keyup", captureKeyUpHandler, true);
+			win.addEventListener("blur", captureBlurHandler);
+			win.addEventListener("contextmenu", captureBlurHandler);
+		}
+		if (phases.bubble) {
+			this.rootNode.addEventListener("keydown", bubbleKeyDownHandler, false);
+			this.rootNode.addEventListener("keyup", bubbleKeyUpHandler, false);
+			win.addEventListener("blur", bubbleBlurHandler);
+			win.addEventListener("contextmenu", bubbleBlurHandler);
+		}
+		this.state.listening = true;
+	}
+	stopListening() {
+		if (!this.rootNode || !this.state.listening) return;
+		const win = getWin(this.rootNode);
+		if (this.listeners.capture.keyDown) this.rootNode.removeEventListener("keydown", this.listeners.capture.keyDown, true);
+		if (this.listeners.capture.keyUp) this.rootNode.removeEventListener("keyup", this.listeners.capture.keyUp, true);
+		if (this.listeners.capture.blur) {
+			win.removeEventListener("blur", this.listeners.capture.blur);
+			win.removeEventListener("contextmenu", this.listeners.capture.blur);
+		}
+		if (this.listeners.bubble.keyDown) this.rootNode.removeEventListener("keydown", this.listeners.bubble.keyDown, false);
+		if (this.listeners.bubble.keyUp) this.rootNode.removeEventListener("keyup", this.listeners.bubble.keyUp, false);
+		if (this.listeners.bubble.blur) {
+			win.removeEventListener("blur", this.listeners.bubble.blur);
+			win.removeEventListener("contextmenu", this.listeners.bubble.blur);
+		}
+		this.listeners.capture = {};
+		this.listeners.bubble = {};
+		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(this.context) : command.enabled)) continue;
+			if (command.options.capture !== false) capture = true;
+			else bubble = true;
+			if (capture && bubble) break;
+		}
+		return {
+			capture,
+			bubble
+		};
+	}
+	createKeyDownHandler(isCapture) {
+		return ((event) => {
+			this.executeMatchingCommands(event, isCapture);
+		});
+	}
+	createKeyUpHandler() {
+		return ((event) => {
+			const eventKey = normalizeKey(event.key);
+			this.state.pressedKeys.delete(eventKey);
+			this.notifySubscribers();
+		});
+	}
+	createBlurHandler() {
+		return (() => {
+			this.state.pressedKeys.clear();
+			for (const hotkey of this.sequenceStates.keys()) this.resetSequence(hotkey);
+			this.notifySubscribers();
+		});
+	}
+	async executeMatchingCommands(event, capture) {
+		const eventKey = normalizeKey(event.key);
+		this.state.pressedKeys.add(eventKey);
+		this.notifySubscribers();
+		const matches = [];
+		for (const [, command] of this.state.commands) {
+			if (!(typeof command.enabled === "function" ? command.enabled(this.context) : command.enabled)) continue;
+			if (command.options.capture !== false !== capture) continue;
+			if (!command.scopes.some((scope) => scope === "*" || this.state.activeScopes.has(scope))) continue;
+			if (!shouldTrigger(event, command.options)) 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();
+			try {
+				await command.action(this.context, event);
+			} catch (error) {
+				console.error(`Error executing hotkey command "${command.id}":`, error);
+			}
+		}
+	}
+	handleSequence(hotkeyString, parsed, eventKey, event) {
+		if (!this.rootNode) {
+			console.warn("Cannot handle sequence: rootNode is not initialized");
+			return false;
+		}
+		const win = getWin(this.rootNode);
+		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) {
+			const keyMatches = eventKey === expectedStep.key;
+			const codeMatches = parsed.codes && parsed.codes[currentStepIndex] === event.code;
+			const modifiersMatch = (expectedStep.alt || false) === event.altKey && (expectedStep.ctrl || false) === event.ctrlKey && (expectedStep.meta || false) === event.metaKey && (expectedStep.shift || false) === event.shiftKey;
+			if ((keyMatches || codeMatches) && modifiersMatch) {
+				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;
+	}
+	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, this.context);
+			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?.rootNode) store.init(options);
+	return store;
+}
+
+//#endregion
+//#region src/shared/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 = new Map([
+	["ArrowUp", "↑"],
+	["ArrowDown", "↓"],
+	["ArrowLeft", "←"],
+	["ArrowRight", "→"],
+	["Backspace", "⌫"],
+	["Delete", "⌦"],
+	["Enter", "↵"],
+	["Tab", "⇥"],
+	["Escape", "Esc"],
+	["Space", "␣"],
+	[" ", "␣"]
+]);
+const KEY_NAMES = 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(SEQUENCE_SEPARATOR)) return hotkey.split(SEQUENCE_SEPARATOR).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
+exports.HotkeyStore = HotkeyStore;
+exports.createHotkeyStore = createHotkeyStore;
+exports.formatHotkey = formatHotkey;
+exports.isHotKey = isHotKey;
+exports.parseHotkey = parseHotkey;