@dolphy-app/keybindings 0.4.0

package/dist/index.js

@@ -0,0 +1,1041 @@
+//#region packages/keybindings/src/platform.ts
+const PLATFORMS = [
+	"mac",
+	"windows",
+	"linux"
+];
+/** Платформа окна по `navigator`: Mac, Windows, всё остальное — Linux. */
+const detectPlatform = (nav) => {
+	const platform = nav.platform ?? "";
+	const agent = nav.userAgent ?? "";
+	if (/^(Mac|iPhone|iPad|iPod)/i.test(platform)) return "mac";
+	if (/^Win/i.test(platform)) return "windows";
+	if (platform === "" && /Macintosh/i.test(agent)) return "mac";
+	if (platform === "" && /Windows/i.test(agent)) return "windows";
+	return "linux";
+};
+/** Платформа процесса Node по `process.platform`. */
+const platformFromNode = (name) => {
+	if (name === "darwin") return "mac";
+	if (name === "win32") return "windows";
+	return "linux";
+};
+
+//#endregion
+//#region packages/keybindings/src/keystroke.ts
+const MAX_CHORD_LENGTH = 2;
+var KeybindingSyntaxError = class extends Error {
+	reason;
+	text;
+	constructor(reason, text) {
+		super(`invalid keybinding "${text}": ${reason}`);
+		this.name = "KeybindingSyntaxError";
+		this.reason = reason;
+		this.text = text;
+	}
+};
+const MODIFIER_ALIASES = {
+	mod: "mod",
+	ctrl: "ctrl",
+	control: "ctrl",
+	alt: "alt",
+	option: "alt",
+	opt: "alt",
+	shift: "shift",
+	meta: "meta",
+	cmd: "meta",
+	command: "meta",
+	win: "meta",
+	super: "meta"
+};
+const NAMED_KEYS = {
+	enter: "enter",
+	return: "enter",
+	escape: "escape",
+	esc: "escape",
+	tab: "tab",
+	space: "space",
+	spacebar: "space",
+	backspace: "backspace",
+	delete: "delete",
+	del: "delete",
+	insert: "insert",
+	ins: "insert",
+	home: "home",
+	end: "end",
+	pageup: "pageup",
+	pgup: "pageup",
+	pagedown: "pagedown",
+	pgdn: "pagedown",
+	arrowup: "arrowup",
+	up: "arrowup",
+	arrowdown: "arrowdown",
+	down: "arrowdown",
+	arrowleft: "arrowleft",
+	left: "arrowleft",
+	arrowright: "arrowright",
+	right: "arrowright",
+	plus: "+"
+};
+const CANONICAL_TEXT = {
+	enter: "Enter",
+	escape: "Escape",
+	tab: "Tab",
+	space: "Space",
+	backspace: "Backspace",
+	delete: "Delete",
+	insert: "Insert",
+	home: "Home",
+	end: "End",
+	pageup: "PageUp",
+	pagedown: "PageDown",
+	arrowup: "ArrowUp",
+	arrowdown: "ArrowDown",
+	arrowleft: "ArrowLeft",
+	arrowright: "ArrowRight"
+};
+const LABELS = {
+	enter: "Enter",
+	escape: "Esc",
+	tab: "Tab",
+	space: "Space",
+	backspace: "Backspace",
+	delete: "Delete",
+	insert: "Insert",
+	home: "Home",
+	end: "End",
+	pageup: "Page Up",
+	pagedown: "Page Down",
+	arrowup: "↑",
+	arrowdown: "↓",
+	arrowleft: "←",
+	arrowright: "→"
+};
+const CODE_KEYS = {
+	Backquote: "`",
+	Minus: "-",
+	Equal: "=",
+	BracketLeft: "[",
+	BracketRight: "]",
+	Backslash: "\\",
+	Semicolon: ";",
+	Quote: "'",
+	Comma: ",",
+	Period: ".",
+	Slash: "/"
+};
+const MODIFIER_ONLY_KEYS = /* @__PURE__ */ new Set([
+	"control",
+	"shift",
+	"alt",
+	"altgraph",
+	"meta",
+	"os",
+	"capslock",
+	"numlock",
+	"fn",
+	"process",
+	"unidentified"
+]);
+const META_LABEL = {
+	mac: "⌘",
+	windows: "Win",
+	linux: "Super"
+};
+const META_WORD = {
+	mac: "command",
+	windows: "windows",
+	linux: "super"
+};
+const FUNCTION_KEY = /^f([1-9]|1\d|2[0-4])$/;
+const PHYSICAL = /^\[([A-Za-z][A-Za-z0-9]*)\]$/;
+const own = (table, key) => Object.hasOwn(table, key) ? table[key] : void 0;
+/** Логическая клавиша, которую даёт физическая: `KeyK` → `k`, `Comma` → `,`; нет соответствия — `undefined`. */
+const codeToKey = (code) => {
+	const letter = /^Key([A-Z])$/.exec(code);
+	if (letter) return letter[1].toLowerCase();
+	const digit = /^Digit(\d)$/.exec(code);
+	if (digit) return digit[1];
+	return own(CODE_KEYS, code);
+};
+const isSingleCharacter = (text) => Array.from(text).length === 1 && !/\s/u.test(text);
+/** Имя клавиши записи в каноническую логическую форму; `null` — неизвестное имя. */
+const normalizeKeyName = (part) => {
+	const lower = part.toLowerCase();
+	const named = own(NAMED_KEYS, lower);
+	if (named !== void 0) return named;
+	if (FUNCTION_KEY.test(lower)) return lower;
+	return isSingleCharacter(part) ? lower : null;
+};
+const stroke = (flags, key, code) => ({
+	ctrl: flags.ctrl,
+	alt: flags.alt,
+	shift: flags.shift,
+	meta: flags.meta,
+	key,
+	code
+});
+/** `Mod++` — клавиша `+`; `Mod+K` — модификаторы и клавиша. */
+const splitStroke = (text) => {
+	if (text === "+") return {
+		modifiers: [],
+		key: "+"
+	};
+	const plus = text.endsWith("++");
+	const index = plus ? text.length - 2 : text.lastIndexOf("+");
+	if (index < 0) return {
+		modifiers: [],
+		key: text
+	};
+	return {
+		modifiers: text.slice(0, index).split("+"),
+		key: plus ? "+" : text.slice(index + 1)
+	};
+};
+const parseStroke = (text, platform, whole) => {
+	const { modifiers, key: keyPart } = splitStroke(text);
+	const flags = {
+		ctrl: false,
+		alt: false,
+		shift: false,
+		meta: false
+	};
+	for (const token of modifiers) {
+		if (token === "") throw new KeybindingSyntaxError("empty-part", whole);
+		const name = own(MODIFIER_ALIASES, token.toLowerCase());
+		if (name === void 0) throw new KeybindingSyntaxError("unknown-modifier", whole);
+		const resolved = name === "mod" ? platform === "mac" ? "meta" : "ctrl" : name;
+		if (flags[resolved]) throw new KeybindingSyntaxError("repeated-modifier", whole);
+		flags[resolved] = true;
+	}
+	if (keyPart === "" || Object.hasOwn(MODIFIER_ALIASES, keyPart.toLowerCase())) throw new KeybindingSyntaxError("modifier-only", whole);
+	const physical = PHYSICAL.exec(keyPart);
+	if (physical) return stroke(flags, "", physical[1]);
+	if (keyPart.length > 1 && (keyPart.startsWith("[") || keyPart.endsWith("]"))) throw new KeybindingSyntaxError("invalid-code", whole);
+	const key = normalizeKeyName(keyPart);
+	if (key === null) throw new KeybindingSyntaxError("unknown-key", whole);
+	return stroke(flags, key, "");
+};
+/**
+* `Mod+Shift+L` или `Mod+K Mod+S` → сочетание для платформы. `Mod` — Meta на
+* macOS и Ctrl на остальных; остальные модификаторы — по имени. Ошибка
+* записи — `KeybindingSyntaxError` с причиной.
+*/
+const parseChord = (text, platform) => {
+	const trimmed = text.trim();
+	if (trimmed === "") throw new KeybindingSyntaxError("empty", text);
+	const parts = trimmed.split(/\s+/);
+	if (parts.length > 2) throw new KeybindingSyntaxError("too-long", text);
+	return parts.map((part) => parseStroke(part, platform, text));
+};
+/** `null` вместо ошибки. */
+const tryParseChord = (text, platform) => {
+	try {
+		return parseChord(text, platform);
+	} catch (error) {
+		if (error instanceof KeybindingSyntaxError) return null;
+		throw error;
+	}
+};
+const keyText = (item) => {
+	if (item.code !== "") return `[${item.code}]`;
+	return own(CANONICAL_TEXT, item.key) ?? item.key.toUpperCase();
+};
+const strokeToText = (item, platform) => {
+	const primary = platform === "mac" ? "meta" : "ctrl";
+	const parts = [];
+	if (item[primary]) parts.push("Mod");
+	if (primary !== "ctrl" && item.ctrl) parts.push("Ctrl");
+	if (item.alt) parts.push("Alt");
+	if (item.shift) parts.push("Shift");
+	if (primary !== "meta" && item.meta) parts.push("Meta");
+	parts.push(keyText(item));
+	return parts.join("+");
+};
+/** Каноническая запись для хранения: `Mod` вместо основного модификатора платформы. */
+const chordToText = (chord, platform) => chord.map((item) => strokeToText(item, platform)).join(" ");
+const labelOfKey = (item) => {
+	if (item.code === "") return own(LABELS, item.key) ?? item.key.toUpperCase();
+	return /^Key([A-Z])$/.exec(item.code)?.[1] ?? /^Digit(\d)$/.exec(item.code)?.[1] ?? item.code;
+};
+const strokeLabel = (item, platform) => {
+	const key = labelOfKey(item);
+	if (platform === "mac") return `${item.ctrl ? "⌃" : ""}${item.alt ? "⌥" : ""}${item.shift ? "⇧" : ""}${item.meta ? "⌘" : ""}${key}`;
+	return [
+		item.ctrl ? "Ctrl" : null,
+		item.alt ? "Alt" : null,
+		item.shift ? "Shift" : null,
+		item.meta ? META_LABEL[platform] : null,
+		key
+	].filter((part) => part !== null).join("+");
+};
+/** Подпись для интерфейса: `⇧⌘L` на macOS, `Ctrl+Shift+L` на остальных; цепочка — через пробел. */
+const formatChord = (chord, platform) => chord.map((item) => strokeLabel(item, platform)).join(" ");
+const SPOKEN_KEYS = {
+	",": "comma",
+	"+": "plus",
+	enter: "enter",
+	escape: "escape",
+	tab: "tab",
+	space: "space",
+	backspace: "backspace",
+	delete: "delete",
+	insert: "insert",
+	home: "home",
+	end: "end",
+	pageup: "pageup",
+	pagedown: "pagedown",
+	arrowup: "arrowup",
+	arrowdown: "arrowdown",
+	arrowleft: "arrowleft",
+	arrowright: "arrowright"
+};
+const spokenStroke = (item, platform, word) => {
+	const mac = platform === "mac";
+	const control = item.ctrl ? word("control") : null;
+	const meta = item.meta ? word(META_WORD[platform]) : null;
+	const spoken = Object.hasOwn(SPOKEN_KEYS, item.key) ? SPOKEN_KEYS[item.key] : void 0;
+	return [
+		...mac ? [meta, control] : [control, meta],
+		item.alt ? word(mac ? "option" : "alt") : null,
+		item.shift ? word("shift") : null,
+		spoken === void 0 ? labelOfKey(item) : word(spoken)
+	].filter((part) => part !== null).join(" ");
+};
+/**
+* Сочетание словами для скринридера: `⌘K` без этого читается как набор
+* символов. На macOS — «Command Option Shift L», иначе — «Control Alt Shift L»;
+* нажатия цепочки разделены запятой.
+*/
+const spokenChord = (chord, platform, word) => chord.map((item) => spokenStroke(item, platform, word)).join(", ");
+/**
+* Ключ сравнения нажатия: модификаторы и клавиша. Физическая клавиша, у
+* которой есть логическое имя (`[KeyK]`), приравнена к нему (`k`): на любой
+* раскладке такие записи могут сработать от одного нажатия.
+*/
+const strokeKey = (item) => {
+	const key = item.code === "" ? item.key : codeToKey(item.code) ?? `[${item.code}]`;
+	return `${`${item.ctrl ? "c" : ""}${item.alt ? "a" : ""}${item.shift ? "s" : ""}${item.meta ? "m" : ""}`}:${key}`;
+};
+/** Сочетание начинается нажатиями `prefix` (или совпадает с ним). */
+const chordStartsWith = (chord, prefix) => prefix.length <= chord.length && prefix.every((item, index) => strokeKey(item) === strokeKey(chord[index]));
+/**
+* Первое нажатие печатает или правит текст (`K`, `Shift+K`, `,`, `Enter`,
+* стрелки): без Ctrl и Meta такое сочетание срабатывало бы при наборе. Не
+* считаются `Escape` и F1–F24.
+*/
+const isTypingChord = (chord) => {
+	const first = chord[0];
+	if (first === void 0 || first.ctrl || first.meta) return false;
+	if (first.code !== "") return true;
+	return first.key !== "escape" && !FUNCTION_KEY.test(first.key);
+};
+const eventKeyName = (key) => {
+	if (key === " ") return "space";
+	if (key.length > 1) return own(NAMED_KEYS, key.toLowerCase()) ?? key.toLowerCase();
+	return key.toLowerCase();
+};
+const isAsciiLetter = (key) => /^[A-Za-z]$/.test(key);
+/** Модификаторы события; AltGr (Ctrl+Alt на Windows) не считается ни тем, ни другим. */
+const eventFlags = (event) => {
+	const altGraph = event.getModifierState?.("AltGraph") === true;
+	return {
+		ctrl: altGraph ? false : event.ctrlKey,
+		alt: altGraph ? false : event.altKey,
+		shift: event.shiftKey,
+		meta: event.metaKey,
+		altGraph
+	};
+};
+/**
+* Событие совпадает с нажатием. Модификаторы — ровно заданные (AltGr не
+* считается Ctrl+Alt). Физическая запись сверяется по `code`. Логическая — по
+* `event.key`: буква ASCII окончательна (Dvorak, Colemak, AZERTY); если `key`
+* не ASCII-буква (русская раскладка, мёртвые клавиши, ⌥+буква на macOS),
+* клавишу определяет `code`. Событие во время IME-ввода не совпадает.
+*/
+const matchKeystroke = (event, expected) => {
+	if (event.isComposing === true) return false;
+	const flags = eventFlags(event);
+	if (flags.altGraph && (expected.ctrl || expected.alt)) return false;
+	if (flags.ctrl !== expected.ctrl || flags.alt !== expected.alt) return false;
+	if (flags.meta !== expected.meta) return false;
+	if (expected.code !== "") return flags.shift === expected.shift && event.code === expected.code;
+	const name = eventKeyName(event.key);
+	if (name === expected.key) {
+		const isSymbol = isSingleCharacter(name) && !/^\p{Letter}$/u.test(name);
+		return flags.shift === expected.shift || isSymbol && !expected.shift;
+	}
+	if (isAsciiLetter(event.key)) return false;
+	if (/^\p{Script=Latin}$/u.test(event.key) && event.code.startsWith("Key") && !event.altKey) return false;
+	return codeToKey(event.code) === expected.key && flags.shift === expected.shift;
+};
+/**
+* Событие в нажатие для записи сочетания в интерфейсе; `null` — одиночный
+* модификатор или клавиша без имени. Именованные клавиши и буква ASCII
+* записываются по `key`, остальное — по логическому имени физической клавиши
+* (`KeyK` на русской раскладке → `k`), без имени — физической записью.
+*/
+const eventToKeystroke = (event) => {
+	const name = eventKeyName(event.key);
+	if (MODIFIER_ONLY_KEYS.has(name)) return null;
+	const { ctrl, alt, shift, meta } = eventFlags(event);
+	const flags = {
+		ctrl,
+		alt,
+		shift,
+		meta
+	};
+	if (name === "space" || Object.hasOwn(CANONICAL_TEXT, name) || FUNCTION_KEY.test(name) || isAsciiLetter(event.key)) return stroke(flags, name, "");
+	const mapped = codeToKey(event.code);
+	if (mapped !== void 0) return stroke(flags, mapped, "");
+	if (isSingleCharacter(event.key)) return stroke(flags, name, "");
+	return event.code === "" ? null : stroke(flags, "", event.code);
+};
+
+//#endregion
+//#region packages/keybindings/src/when.ts
+const WHEN_MAX_LENGTH = 256;
+const MAX_DEPTH = 16;
+const MAX_TERMS = 64;
+var WhenSyntaxError = class extends Error {
+	reason;
+	/** Позиция ошибки в тексте (индекс символа). */
+	position;
+	constructor(reason, position) {
+		super(`invalid when clause: ${reason} at ${position}`);
+		this.name = "WhenSyntaxError";
+		this.reason = reason;
+		this.position = position;
+	}
+};
+const IDENT = /[A-Za-z_][A-Za-z0-9_.-]*/y;
+const BARE = /[^\s&|()!='"]+/y;
+const matchAt = (pattern, text, index) => {
+	pattern.lastIndex = index;
+	return pattern.exec(text)?.[0] ?? null;
+};
+/** После `==`/`!=` значение — слово или строка в одинарных кавычках. */
+const tokenize = (text) => {
+	const tokens = [];
+	let index = 0;
+	let expectValue = false;
+	while (index < text.length) {
+		const char = text[index];
+		if (/\s/.test(char)) {
+			index++;
+			continue;
+		}
+		const two = text.slice(index, index + 2);
+		if (two === "&&" || two === "||" || two === "==" || two === "!=") {
+			tokens.push({
+				kind: "op",
+				text: two,
+				position: index
+			});
+			expectValue = two === "==" || two === "!=";
+			index += 2;
+			continue;
+		}
+		if (char === "(" || char === ")" || char === "!") {
+			tokens.push({
+				kind: "op",
+				text: char,
+				position: index
+			});
+			expectValue = false;
+			index++;
+			continue;
+		}
+		if (char === "'") {
+			const close = text.indexOf("'", index + 1);
+			if (close < 0) throw new WhenSyntaxError("unterminated-string", index);
+			tokens.push({
+				kind: "value",
+				text: text.slice(index + 1, close),
+				position: index
+			});
+			expectValue = false;
+			index = close + 1;
+			continue;
+		}
+		const word = matchAt(expectValue ? BARE : IDENT, text, index);
+		if (word === null) throw new WhenSyntaxError("unexpected-token", index);
+		tokens.push({
+			kind: expectValue ? "value" : "ident",
+			text: word,
+			position: index
+		});
+		expectValue = false;
+		index += word.length;
+	}
+	tokens.push({
+		kind: "end",
+		text: "",
+		position: text.length
+	});
+	return tokens;
+};
+var Parser = class {
+	index = 0;
+	tokens;
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	parse() {
+		const result = this.parseOr(0);
+		if (this.peek().kind !== "end") this.fail();
+		return result;
+	}
+	peek() {
+		return this.tokens[this.index];
+	}
+	isOp(text) {
+		const token = this.peek();
+		return token.kind === "op" && token.text === text;
+	}
+	fail() {
+		const token = this.peek();
+		throw new WhenSyntaxError(token.kind === "end" ? "unexpected-end" : "unexpected-token", token.position);
+	}
+	parseOr(depth) {
+		if (depth > MAX_DEPTH) throw new WhenSyntaxError("too-deep", this.peek().position);
+		const terms = [this.parseAnd(depth)];
+		while (this.isOp("||")) {
+			this.index++;
+			terms.push(this.parseAnd(depth));
+		}
+		return terms.length === 1 ? terms[0] : {
+			type: "or",
+			terms
+		};
+	}
+	parseAnd(depth) {
+		const terms = [this.parseUnary(depth)];
+		while (this.isOp("&&")) {
+			this.index++;
+			terms.push(this.parseUnary(depth));
+		}
+		return terms.length === 1 ? terms[0] : {
+			type: "and",
+			terms
+		};
+	}
+	parseUnary(depth) {
+		if (this.isOp("!")) {
+			this.index++;
+			if (this.isOp("(")) return {
+				type: "not",
+				expr: this.parseGroup(depth)
+			};
+			const token = this.peek();
+			if (token.kind !== "ident") return this.fail();
+			this.index++;
+			return {
+				type: "not",
+				expr: {
+					type: "key",
+					key: token.text
+				}
+			};
+		}
+		if (this.isOp("(")) return this.parseGroup(depth);
+		const token = this.peek();
+		if (token.kind !== "ident") return this.fail();
+		this.index++;
+		if (this.isOp("==") || this.isOp("!=")) {
+			const operator = this.peek().text;
+			this.index++;
+			const value = this.peek();
+			if (value.kind !== "value") return this.fail();
+			this.index++;
+			return {
+				type: operator === "==" ? "eq" : "neq",
+				key: token.text,
+				value: value.text
+			};
+		}
+		return {
+			type: "key",
+			key: token.text
+		};
+	}
+	parseGroup(depth) {
+		this.index++;
+		const inner = this.parseOr(depth + 1);
+		if (!this.isOp(")")) return this.fail();
+		this.index++;
+		return inner;
+	}
+};
+/** Текст условия → выражение; ошибка — `WhenSyntaxError` с причиной и позицией. */
+const parseWhen = (text) => {
+	if (text.length > 256) throw new WhenSyntaxError("too-long", 0);
+	if (text.trim() === "") throw new WhenSyntaxError("empty", 0);
+	return new Parser(tokenize(text)).parse();
+};
+/** `null` вместо ошибки. */
+const tryParseWhen = (text) => {
+	try {
+		return parseWhen(text);
+	} catch (error) {
+		if (error instanceof WhenSyntaxError) return null;
+		throw error;
+	}
+};
+const needsQuotes = (value) => !/^[^\s&|()!='"]+$/.test(value);
+/** Каноническая запись выражения (скобки только где нужны). */
+const whenToText = (expr, parent = 0) => {
+	switch (expr.type) {
+		case "key": return expr.key;
+		case "not": return expr.expr.type === "key" ? `!${expr.expr.key}` : `!(${whenToText(expr.expr)})`;
+		case "eq":
+		case "neq": {
+			const value = needsQuotes(expr.value) ? `'${expr.value}'` : expr.value;
+			return `${expr.key} ${expr.type === "eq" ? "==" : "!="} ${value}`;
+		}
+		case "and": {
+			const text = expr.terms.map((term) => whenToText(term, 2)).join(" && ");
+			return parent > 2 ? `(${text})` : text;
+		}
+		default: {
+			const text = expr.terms.map((term) => whenToText(term, 1)).join(" || ");
+			return parent > 1 ? `(${text})` : text;
+		}
+	}
+};
+const isTruthy = (value) => value !== void 0 && value !== null && value !== false && value !== "" && value !== 0;
+/**
+* Выражение истинно в контексте. `null` (нет условия) — всегда истина;
+* неизвестный ключ — ложь; сравнение — по строковому виду значения, у
+* незаданного ключа `==` ложно, а `!=` истинно.
+*/
+const evaluateWhen = (expr, lookup) => {
+	if (expr === null) return true;
+	switch (expr.type) {
+		case "key": return isTruthy(lookup(expr.key));
+		case "not": return !evaluateWhen(expr.expr, lookup);
+		case "eq": {
+			const value = lookup(expr.key);
+			return value !== void 0 && String(value) === expr.value;
+		}
+		case "neq": {
+			const value = lookup(expr.key);
+			return value === void 0 || String(value) !== expr.value;
+		}
+		case "and": return expr.terms.every((term) => evaluateWhen(term, lookup));
+		default: return expr.terms.some((term) => evaluateWhen(term, lookup));
+	}
+};
+/** Дизъюнкция конъюнкций литералов; `null` — слишком много термов. */
+const toDnf = (expr, negated) => {
+	switch (expr.type) {
+		case "key": return [[{
+			kind: negated ? "falsy" : "truthy",
+			key: expr.key
+		}]];
+		case "eq":
+		case "neq": return [[{
+			kind: expr.type === "eq" !== negated ? "eq" : "neq",
+			key: expr.key,
+			value: expr.value
+		}]];
+		case "not": return toDnf(expr.expr, !negated);
+		default: {
+			const isConjunction = expr.type === "and" !== negated;
+			let result = isConjunction ? [[]] : [];
+			for (const part of expr.terms) {
+				const dnf = toDnf(part, negated);
+				if (dnf === null || result === null) return null;
+				const current = result;
+				result = isConjunction ? dnf.flatMap((right) => current.map((left) => [...left, ...right])) : [...current, ...dnf];
+				if (result.length > MAX_TERMS) return null;
+			}
+			return result;
+		}
+	}
+};
+/** Значение `value`, при котором `ключ == value` истинно, обязательно истинно или ложно как условие. */
+const forcedTruth = (value) => {
+	if (value === "") return false;
+	if (value === "false" || value === "0") return null;
+	return true;
+};
+const isConsistent = (term) => {
+	const states = /* @__PURE__ */ new Map();
+	for (const literal of term) {
+		let state = states.get(literal.key);
+		if (state === void 0) {
+			state = {
+				truthy: null,
+				eq: null,
+				neq: /* @__PURE__ */ new Set()
+			};
+			states.set(literal.key, state);
+		}
+		if (literal.kind === "truthy" || literal.kind === "falsy") {
+			const wanted = literal.kind === "truthy";
+			if (state.truthy !== null && state.truthy !== wanted) return false;
+			state.truthy = wanted;
+		} else if (literal.kind === "eq") {
+			if (state.eq !== null && state.eq !== literal.value) return false;
+			state.eq = literal.value;
+		} else state.neq.add(literal.value);
+	}
+	for (const state of states.values()) {
+		if (state.eq === null) continue;
+		if (state.neq.has(state.eq)) return false;
+		const forced = forcedTruth(state.eq);
+		if (forced !== null && state.truthy !== null && state.truthy !== forced) return false;
+	}
+	return true;
+};
+/**
+* Могут ли оба условия быть истинными одновременно. `null` — нет условия.
+* Сверх 64 термов в нормальной форме ответ «да» (лучше лишнее предупреждение,
+* чем молчание).
+*/
+const whenOverlaps = (left, right) => {
+	if (left === null || right === null) return true;
+	const leftDnf = toDnf(left, false);
+	const rightDnf = toDnf(right, false);
+	if (leftDnf === null || rightDnf === null) return true;
+	return leftDnf.some((a) => rightDnf.some((b) => isConsistent([...a, ...b])));
+};
+
+//#endregion
+//#region packages/keybindings/src/keymap.ts
+const SOURCE_WEIGHT = {
+	extension: 0,
+	default: 1,
+	user: 2
+};
+const SOURCE_STEP = 1e6;
+const issueReason = (error) => {
+	if (error instanceof KeybindingSyntaxError) return error.reason;
+	if (error instanceof WhenSyntaxError) return error.reason;
+	return null;
+};
+const compare = (left, right) => {
+	const common = Math.min(left.chord.length, right.chord.length);
+	for (let index = 0; index < common; index++) if (strokeKey(left.chord[index]) !== strokeKey(right.chord[index])) return null;
+	return left.chord.length === right.chord.length ? "same" : "prefix";
+};
+/** Пересечение двух привязок разных команд или `null`. */
+const conflictOf = (left, right) => {
+	if (left.command === right.command) return null;
+	const kind = compare(left, right);
+	if (kind === null || !whenOverlaps(left.when, right.when)) return null;
+	return left.rank >= right.rank ? {
+		kind,
+		winner: left,
+		loser: right
+	} : {
+		kind,
+		winner: right,
+		loser: left
+	};
+};
+const findConflictsIn = (bindings) => {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const binding of bindings) {
+		const key = strokeKey(binding.chord[0]);
+		const bucket = buckets.get(key);
+		if (bucket === void 0) buckets.set(key, [binding]);
+		else bucket.push(binding);
+	}
+	const conflicts = [];
+	for (const bucket of buckets.values()) for (let i = 0; i < bucket.length; i++) for (let j = i + 1; j < bucket.length; j++) {
+		const conflict = conflictOf(bucket[i], bucket[j]);
+		if (conflict !== null) conflicts.push(conflict);
+	}
+	return conflicts;
+};
+const compile = (raw, platform, issues) => {
+	const problem = (field, error) => {
+		const reason = issueReason(error);
+		if (reason === null) throw error;
+		issues.push({
+			source: raw.source,
+			command: raw.command,
+			key: raw.key,
+			when: raw.when,
+			field,
+			reason
+		});
+		return null;
+	};
+	let chord;
+	try {
+		chord = parseChord(raw.key, platform);
+	} catch (error) {
+		return problem("key", error);
+	}
+	let when = null;
+	if (raw.when !== null && raw.when.trim() !== "") try {
+		when = parseWhen(raw.when);
+	} catch (error) {
+		return problem("when", error);
+	}
+	return {
+		command: raw.command,
+		source: raw.source,
+		text: raw.key,
+		chord,
+		when,
+		whenText: when === null ? null : whenToText(when),
+		rank: SOURCE_WEIGHT[raw.source] * SOURCE_STEP + raw.index
+	};
+};
+const definitionKey = (definition, platform) => definition[platform] ?? definition.key;
+/**
+* Собирает действующие привязки: набор пользователя заменяет привязки команды
+* из кода и расширений целиком; приоритет `user` > `default` > `extension`,
+* внутри источника позднее выше. Записи, которые не разбираются (повреждённые
+* данные), пропускаются и попадают в `issues`.
+*/
+const buildKeymap = (input) => {
+	const { platform, user } = input;
+	const issues = [];
+	const replaced = new Set(Object.keys(user));
+	const raws = [];
+	const addDefinitions = (definitions, source) => {
+		definitions.forEach((definition, index) => {
+			if (replaced.has(definition.command)) return;
+			raws.push({
+				command: definition.command,
+				source,
+				key: definitionKey(definition, platform),
+				when: definition.when ?? null,
+				index
+			});
+		});
+	};
+	addDefinitions(input.defaults, "default");
+	addDefinitions(input.extensions, "extension");
+	let userIndex = 0;
+	for (const [command, entries] of Object.entries(user)) for (const entry of entries) raws.push({
+		command,
+		source: "user",
+		key: entry.key,
+		when: entry.when,
+		index: userIndex++
+	});
+	const bindings = raws.map((raw) => compile(raw, platform, issues)).filter((binding) => binding !== null).sort((left, right) => right.rank - left.rank);
+	const byCommand = /* @__PURE__ */ new Map();
+	for (const binding of bindings) {
+		const list = byCommand.get(binding.command);
+		if (list === void 0) byCommand.set(binding.command, [binding]);
+		else list.push(binding);
+	}
+	return {
+		bindings,
+		issues,
+		forCommand: (command) => byCommand.get(command) ?? [],
+		resolve: (presses, lookup, isEnabled) => {
+			for (const binding of bindings) {
+				if (binding.chord.length < presses.length) continue;
+				if (!presses.every((press, index) => matchKeystroke(press, binding.chord[index]))) continue;
+				if (!evaluateWhen(binding.when, lookup)) continue;
+				if (isEnabled !== void 0 && !isEnabled(binding.command)) continue;
+				return binding.chord.length > presses.length ? {
+					kind: "pending",
+					binding
+				} : {
+					kind: "run",
+					binding
+				};
+			}
+			return { kind: "none" };
+		},
+		conflicts: () => findConflictsIn(bindings)
+	};
+};
+/**
+* Пересечения кандидата с действующими привязками **других** команд (набор
+* самой команды заменяется кандидатами, поэтому его привязки не сравниваются).
+* Для интерфейса записи сочетания: список до сохранения.
+*/
+const findCandidateConflicts = (keymap, candidate) => {
+	const self = {
+		command: candidate.command,
+		source: "user",
+		text: "",
+		chord: candidate.chord,
+		when: candidate.when,
+		whenText: null,
+		rank: Number.MAX_SAFE_INTEGER
+	};
+	return keymap.bindings.map((binding) => conflictOf(self, binding)).filter((conflict) => conflict !== null);
+};
+
+//#endregion
+//#region packages/keybindings/src/validate.ts
+const KEY_MAX_LENGTH = 64;
+/** Условие «фокус в поле ввода»: привязка с набором, который с ним пересекается, срабатывала бы при наборе. */
+const WHILE_TYPING = {
+	type: "key",
+	key: "inputFocus"
+};
+const TYPING = {
+	field: "when",
+	reason: "typing",
+	detail: "typing"
+};
+/**
+* Проверка привязки: клавиши (на каждой из `platforms`: `Mod` раскрывается по
+* платформе, и запись вроде `Mod+Ctrl+K` верна не везде), условие и правило
+* «сочетание без Ctrl и Meta, которое печатает или правит текст, должно быть
+* неактивно, пока фокус в поле ввода». `null` — привязка верна.
+*/
+const validateBinding = (binding, platforms) => {
+	if (binding.key.length > 64) return {
+		field: "key",
+		reason: "syntax",
+		detail: "too-long-text"
+	};
+	let typing = false;
+	for (const platform of platforms) try {
+		typing ||= isTypingChord(parseChord(binding.key, platform));
+	} catch (error) {
+		if (error instanceof KeybindingSyntaxError) return {
+			field: "key",
+			reason: "syntax",
+			detail: error.reason
+		};
+		throw error;
+	}
+	if (binding.when === null || binding.when.trim() === "") return typing ? TYPING : null;
+	try {
+		const when = parseWhen(binding.when);
+		return typing && whenOverlaps(when, WHILE_TYPING) ? TYPING : null;
+	} catch (error) {
+		if (error instanceof WhenSyntaxError) return {
+			field: "when",
+			reason: "syntax",
+			detail: error.reason,
+			position: error.position
+		};
+		throw error;
+	}
+};
+
+//#endregion
+//#region packages/keybindings/src/user.ts
+const KEYBINDING_LIMITS = {
+	commands: 512,
+	entriesPerCommand: 8,
+	commandLength: 200
+};
+/** Ключ команды в реестре окна: `app:<id>` или `extension:<extensionId>:<id>`. */
+const COMMAND_KEY_PATTERN = /^(app|extension):[A-Za-z0-9._:-]+$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const decodeEntry = (value) => {
+	if (!isRecord(value) || typeof value.key !== "string") return null;
+	const when = value.when ?? null;
+	if (when !== null && typeof when !== "string") return null;
+	return {
+		key: value.key,
+		when
+	};
+};
+/**
+* Хранимое значение → пользовательские привязки. Терпимо к мусору: команды с
+* неверным ключом или не массивом и записи неверной формы отбрасываются,
+* лишнее сверх лимитов обрезается; разбор клавиш и условий — дело карты и
+* `validateUserKeybindings`.
+*/
+const decodeUserKeybindings = (raw) => {
+	const result = {};
+	if (!isRecord(raw) || !isRecord(raw.commands)) return result;
+	for (const [command, entries] of Object.entries(raw.commands)) {
+		if (Object.keys(result).length >= KEYBINDING_LIMITS.commands) break;
+		if (!(command.length <= KEYBINDING_LIMITS.commandLength && COMMAND_KEY_PATTERN.test(command)) || !Array.isArray(entries)) continue;
+		result[command] = entries.map(decodeEntry).filter((entry) => entry !== null).slice(0, KEYBINDING_LIMITS.entriesPerCommand);
+	}
+	return result;
+};
+const keyIdentity = (entry, platform) => {
+	const chord = tryParseChord(entry.key, platform);
+	const when = entry.when === null ? null : tryParseWhen(entry.when);
+	return `${chord?.map(strokeKey).join(" ") ?? entry.key}|${when === null ? "" : whenToText(when)}`;
+};
+/**
+* Проверка набора пользователя на платформе хоста: лимиты, форма ключей
+* команд, клавиши и условия (`validateBinding`), повтор «клавиши + условие»
+* в одной команде и пересечения привязок разных команд. Пустой список — набор
+* верен.
+*/
+const validateUserKeybindings = (user, platform) => {
+	const issues = [];
+	const commands = Object.entries(user);
+	if (commands.length > KEYBINDING_LIMITS.commands) issues.push({
+		reason: "limit",
+		field: "commands",
+		command: "",
+		message: `at most ${KEYBINDING_LIMITS.commands} commands`
+	});
+	const valid = {};
+	for (const [command, entries] of commands) {
+		const field = `commands.${command}`;
+		if (command.length > KEYBINDING_LIMITS.commandLength || !COMMAND_KEY_PATTERN.test(command)) {
+			issues.push({
+				reason: command.length > KEYBINDING_LIMITS.commandLength ? "limit" : "syntax",
+				field,
+				command,
+				message: "invalid command key"
+			});
+			continue;
+		}
+		if (entries.length > KEYBINDING_LIMITS.entriesPerCommand) issues.push({
+			reason: "limit",
+			field,
+			command,
+			message: `at most ${KEYBINDING_LIMITS.entriesPerCommand} bindings per command`
+		});
+		const seen = /* @__PURE__ */ new Set();
+		const accepted = [];
+		entries.forEach((entry, index) => {
+			const problem = validateBinding(entry, [platform]);
+			if (problem !== null) {
+				issues.push({
+					reason: problem.reason,
+					field: `${field}[${index}].${problem.field}`,
+					command,
+					message: `${problem.field}: ${problem.detail}`
+				});
+				return;
+			}
+			const identity = keyIdentity(entry, platform);
+			if (seen.has(identity)) {
+				issues.push({
+					reason: "duplicate",
+					field: `${field}[${index}]`,
+					command,
+					message: "the same key and condition are listed twice"
+				});
+				return;
+			}
+			seen.add(identity);
+			accepted.push(entry);
+		});
+		valid[command] = accepted;
+	}
+	const keymap = buildKeymap({
+		platform,
+		defaults: [],
+		extensions: [],
+		user: valid
+	});
+	for (const { winner, loser } of keymap.conflicts()) issues.push({
+		reason: "conflict",
+		field: `commands.${loser.command}`,
+		command: loser.command,
+		other: winner.command,
+		message: `${loser.text} overlaps ${winner.text} of ${winner.command}`
+	});
+	return issues;
+};
+
+//#endregion
+export { COMMAND_KEY_PATTERN, KEYBINDING_LIMITS, KEY_MAX_LENGTH, KeybindingSyntaxError, MAX_CHORD_LENGTH, PLATFORMS, WHEN_MAX_LENGTH, WhenSyntaxError, buildKeymap, chordStartsWith, chordToText, codeToKey, decodeUserKeybindings, detectPlatform, evaluateWhen, eventToKeystroke, findCandidateConflicts, formatChord, isTypingChord, matchKeystroke, parseChord, parseWhen, platformFromNode, spokenChord, strokeKey, tryParseChord, tryParseWhen, validateBinding, validateUserKeybindings, whenOverlaps, whenToText };