@inklu/keys 2.1.0 → 3.0.0

package/dist/src-CGKvYKjd.mjs

@@ -0,0 +1,1333 @@
+//#region src/chord.ts
+/** The platform, as `navigator` reports it. `"other"` where there is none. */
+function detectPlatform() {
+	if (typeof navigator === "undefined") return "other";
+	return /mac/i.test(`${navigator.platform} ${navigator.userAgent}`) ? "mac" : "other";
+}
+/** Named keys in the `Key` type, as `KeyboardEvent.key` spells them. Other names still work. */
+const NAMED_KEYS = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown",
+	"Enter",
+	"Escape",
+	"Space",
+	"Tab",
+	"Backspace",
+	"Delete",
+	"Insert",
+	"CapsLock",
+	"ContextMenu",
+	"PrintScreen",
+	"ScrollLock",
+	"Pause",
+	"NumLock",
+	"Help",
+	"Clear",
+	"MediaPlayPause",
+	"MediaStop",
+	"MediaTrackNext",
+	"MediaTrackPrevious",
+	"AudioVolumeUp",
+	"AudioVolumeDown",
+	"AudioVolumeMute",
+	"BrowserBack",
+	"BrowserForward",
+	"BrowserRefresh",
+	"BrowserSearch",
+	"BrowserHome"
+];
+const MODIFIERS = [
+	"Control",
+	"Alt",
+	"Shift",
+	"Meta"
+];
+const FUNCTION_KEY = /^F([1-9]|1\d|2[0-4])$/;
+const LETTER = /^\p{Letter}$/u;
+const LATIN_LETTER = /^\p{Script_Extensions=Latin}$/u;
+/** Splits on `+`. The plus key itself is written last: `+` alone, or `Control++`. */
+function split(chord) {
+	const plusKey = chord === "+" || chord.endsWith("++");
+	const parts = (plusKey ? chord.slice(0, -1) : chord).split("+");
+	if (plusKey) parts[parts.length - 1] = "+";
+	return parts.map((part) => part.trim());
+}
+/** One spelling per key: letters upper-cased, the space bar by name. */
+function keyName(key) {
+	if (key === " ") return "Space";
+	if (!LETTER.test(key)) return key;
+	const upper = key.toUpperCase();
+	return upper.length === 1 ? upper : key;
+}
+/** The key a keypress produced. Empty for the keyless events browser autofill dispatches. */
+function pressedKey(event) {
+	return keyName(String(event.key ?? "").normalize("NFC"));
+}
+const isOneCharacter = (key) => Array.from(key).length === 1;
+const isAscii = (key) => /^[\x21-\x7e]$/.test(key);
+/** A one-character key that is not a letter: a digit or a symbol. */
+const isSymbol = (key) => isOneCharacter(key) && !LETTER.test(key);
+/** `KeyboardEvent.key` values that name neither a character nor a key. */
+const NO_KEY = /* @__PURE__ */ new Set([
+	"",
+	"Dead",
+	"Unidentified",
+	"Process"
+]);
+/** A key known by name rather than by a character, such as `Enter`. */
+const isNamed = (key) => !isOneCharacter(key) && !NO_KEY.has(key);
+/** Reads a chord, or says why it cannot be read. */
+function read(chord, platform) {
+	if (chord.trim() === "") return "Chord cannot be empty";
+	const parts = split(chord);
+	const key = parts.pop() ?? "";
+	if (key === "" || parts.includes("")) return "Invalid chord: empty part";
+	if (parts.includes("Mod") && (parts.includes("Control") || parts.includes("Meta"))) return "Mod already stands for Control or Meta: write one or the other";
+	const held = /* @__PURE__ */ new Set();
+	for (const part of parts) {
+		const name = part === "Mod" ? platform === "mac" ? "Meta" : "Control" : part;
+		const modifier = MODIFIERS.find((candidate) => candidate === name);
+		if (!modifier) return `Unknown modifier: '${part}'`;
+		if (held.has(modifier)) return `Repeated modifier: '${part}'`;
+		held.add(modifier);
+	}
+	return {
+		ctrl: held.has("Control"),
+		alt: held.has("Alt"),
+		shift: held.has("Shift"),
+		meta: held.has("Meta"),
+		key: keyName(key)
+	};
+}
+/** Parses a chord for a platform, or returns `null` for one that cannot be read. */
+function parseChord(chord, platform) {
+	const result = read(chord, platform);
+	return typeof result === "string" ? null : result;
+}
+/** Whether a string is a chord this package can read. */
+function isChord(text) {
+	return parseChord(text, "mac") !== null;
+}
+/** A chord's `errors` (it will never fire) and `warnings` (a key name this package does not know). */
+function validateChord(chord) {
+	const result = read(chord, "mac");
+	if (typeof result === "string") return {
+		errors: [result],
+		warnings: []
+	};
+	const { key } = result;
+	const known = isOneCharacter(key) || FUNCTION_KEY.test(key) || NAMED_KEYS.some((name) => name === key);
+	const warnings = [];
+	if (!known) warnings.push(`Unknown key: '${key}'. Key names are KeyboardEvent.key values, such as Escape.`);
+	if (result.shift && isSymbol(key) && !/\d/.test(key)) warnings.push(`Shift+${key} never fires: write the symbol the key types with Shift held, such as '?'.`);
+	return {
+		errors: [],
+		warnings
+	};
+}
+/** Writes a parsed chord as text. Given a platform, its primary modifier is written `Mod`. */
+function writeChord(chord, mod) {
+	const portable = mod !== void 0 && (mod === "mac" ? chord.meta && !chord.ctrl : chord.ctrl && !chord.meta);
+	const parts = portable ? ["Mod"] : [];
+	if (chord.ctrl && !portable) parts.push("Control");
+	if (chord.alt) parts.push("Alt");
+	if (chord.shift) parts.push("Shift");
+	if (chord.meta && !portable) parts.push("Meta");
+	parts.push(chord.key);
+	return parts.join("+");
+}
+/** Whether a chord types a character: a one-character key with no Control, Alt or Meta. */
+function typesCharacter(chord) {
+	return !chord.ctrl && !chord.alt && !chord.meta && isOneCharacter(chord.key);
+}
+const MODIFIER_KEYS = /* @__PURE__ */ new Set([
+	...MODIFIERS,
+	"AltGraph",
+	"OS",
+	"Fn",
+	"Hyper",
+	"Super",
+	"Symbol"
+]);
+/** Whether a `KeyboardEvent.key` is a modifier on its own. */
+function isModifierKey(key) {
+	return MODIFIER_KEYS.has(key);
+}
+/** Whether AltGr is down. Windows reports it as Control+Alt, though a character is being typed. */
+function hasAltGraph(event, platform) {
+	return platform !== "mac" && event.getModifierState?.("AltGraph") === true;
+}
+/** The punctuation keys of the conventional (US) layout, by `KeyboardEvent.code`. */
+const PUNCTUATION_CODES = {
+	Backquote: "`",
+	Backslash: "\\",
+	BracketLeft: "[",
+	BracketRight: "]",
+	Comma: ",",
+	Equal: "=",
+	Minus: "-",
+	Period: ".",
+	Quote: "'",
+	Semicolon: ";",
+	Slash: "/"
+};
+/**
+* The key at a keypress's position on the US layout, where that stands in for
+* what the layout typed: on the digit row always (`Mod+1` on AZERTY, whose
+* digit row types symbols), and on a letter or punctuation key when the layout
+* typed no Latin character there (Cyrillic or Greek, or a key macOS Option altered).
+*/
+function positionKey(event, key) {
+	const code = event.code;
+	if (/^Digit\d$/.test(code)) return code.slice(5);
+	if (isAscii(key) || LATIN_LETTER.test(key) && !event.altKey) return void 0;
+	return /^Key[A-Z]$/.test(code) ? code.slice(3) : PUNCTUATION_CODES[code];
+}
+/**
+* Whether a keypress is this chord: the key it names was typed, or sits at
+* that position where `positionKey` allows, with the same modifiers held. A
+* symbol carries the Shift it took to type (`?` is Shift+/ on a US keyboard),
+* so that Shift need not be named.
+*/
+function matchesChord(event, chord, platform) {
+	const altGraph = hasAltGraph(event, platform);
+	if (altGraph && (chord.ctrl || chord.alt)) return false;
+	const key = pressedKey(event);
+	const typed = key === chord.key && isSymbol(key);
+	return (key === chord.key || !altGraph && positionKey(event, key) === chord.key) && (!altGraph && event.ctrlKey) === chord.ctrl && ((!altGraph && event.altKey) === chord.alt || typed && event.altKey && platform === "mac") && event.metaKey === chord.meta && (event.shiftKey === chord.shift || typed && event.shiftKey);
+}
+/**
+* The chord a keypress expresses, for recording a shortcut, or `null` for a
+* modifier on its own or a key with no name. It records what `matchesChord`
+* then matches: the character typed (`?`, not `Shift+/`), else the key's
+* position, with the primary modifier written `Mod`.
+*/
+function readChord(event, platform) {
+	if (isModifierKey(event.key)) return null;
+	const pressed = pressedKey(event);
+	const altGraph = hasAltGraph(event, platform);
+	const key = altGraph || isAscii(pressed) || isNamed(pressed) ? pressed : positionKey(event, pressed) ?? pressed;
+	if (NO_KEY.has(key)) return null;
+	const typed = key === pressed && isSymbol(key);
+	const chord = writeChord({
+		ctrl: !altGraph && event.ctrlKey,
+		alt: !altGraph && event.altKey && !(typed && platform === "mac"),
+		shift: event.shiftKey && !typed,
+		meta: event.metaKey,
+		key
+	}, platform);
+	return isChord(chord) ? chord : null;
+}
+//#endregion
+//#region src/bindings.ts
+/** Bindings: a chord or a sequence of them. Comparing, validating and reading per platform. */
+/**
+* Creates a sequence binding from ordered chords.
+*
+* @example
+* ```ts
+* keys: seq("G", "I")
+* ```
+*/
+function seq(...steps) {
+	return { sequence: steps };
+}
+/** Type guard checking if a binding is a sequence. */
+function isSequence(binding) {
+	return typeof binding === "object" && binding !== null && "sequence" in binding;
+}
+/** The chords of a binding, in order: one for a chord, several for a sequence. */
+function stepsOf(binding) {
+	return isSequence(binding) ? binding.sequence : [binding];
+}
+/** Normalizes a binding input into an array of bindings. A one-step sequence becomes a chord. */
+function toBindings(input) {
+	if (input == null) return [];
+	const candidates = Array.isArray(input) ? input : [input];
+	const bindings = [];
+	for (const candidate of candidates) {
+		if (candidate == null) continue;
+		const [first, ...rest] = stepsOf(candidate);
+		if (first === void 0) continue;
+		if (rest.length > 0) bindings.push({ sequence: [first, ...rest] });
+		else if (first.trim() !== "") bindings.push(first);
+	}
+	return bindings;
+}
+/** The side of `{ mac, other }` keys that applies on a platform. Keys that do not differ pass through. */
+function keysFor(keys, platform) {
+	if (keys == null || !isPerPlatform(keys)) return keys;
+	return platform === "mac" ? keys.mac : keys.other;
+}
+function isPerPlatform(keys) {
+	return typeof keys === "object" && !Array.isArray(keys) && !("sequence" in keys);
+}
+/** One spelling of a binding on a platform, so equivalent bindings compare equal. */
+function bindingSignature(binding, platform) {
+	return canonicalSteps(binding, platform).join(" ");
+}
+/** Whether one binding is a strict prefix of the other, like chord `G` against `G then I`. */
+function isPrefixCollision(a, b, platform) {
+	const left = canonicalSteps(a, platform);
+	const right = canonicalSteps(b, platform);
+	if (left.length === right.length) return false;
+	const [short, long] = left.length < right.length ? [left, right] : [right, left];
+	return short.every((step, index) => step === long[index]);
+}
+/** Every step parsed for a platform, or `null` if any of them cannot be read. */
+function parseBinding(binding, platform) {
+	const steps = [];
+	for (const step of stepsOf(binding)) {
+		const parsed = parseChord(step, platform);
+		if (!parsed) return null;
+		steps.push(parsed);
+	}
+	return steps;
+}
+/** Each step in one spelling. One that cannot be read stays as written. */
+function canonicalSteps(binding, platform) {
+	return stepsOf(binding).map((step) => {
+		const parsed = parseChord(step, platform);
+		return parsed ? writeChord(parsed) : step;
+	});
+}
+/**
+* Whether every step is a printable character with no Control, Alt or Meta:
+* the "character key shortcuts" WCAG 2.1.4 lets users turn off.
+*/
+function isSingleKeyBinding(binding) {
+	return parseBinding(binding, "mac")?.every(typesCharacter) === true;
+}
+/** A binding's syntax `errors` (it will never fire) and `warnings`, for the development audit. */
+function validateBinding(binding) {
+	const results = stepsOf(binding).map(validateChord);
+	return {
+		errors: results.flatMap((result) => result.errors),
+		warnings: results.flatMap((result) => result.warnings)
+	};
+}
+//#endregion
+//#region src/display.ts
+/** Writing a binding for people: on screen, and in `aria-keyshortcuts`. */
+const MODIFIER_LABELS = {
+	mac: [
+		"⌃",
+		"⌥",
+		"⇧",
+		"⌘"
+	],
+	other: [
+		"Ctrl",
+		"Alt",
+		"Shift",
+		"Meta"
+	]
+};
+/** Named keys as each platform's keyboard prints them: on a Mac, then on Windows and Linux. */
+const KEY_LABELS = {
+	Enter: ["↩", "Enter"],
+	Backspace: ["⌫", "Backspace"],
+	Delete: ["⌦", "Del"],
+	Tab: ["⇥", "Tab"],
+	Escape: ["⎋", "Esc"],
+	ArrowUp: ["↑", "↑"],
+	ArrowDown: ["↓", "↓"],
+	ArrowLeft: ["←", "←"],
+	ArrowRight: ["→", "→"],
+	Home: ["↖", "Home"],
+	End: ["↘", "End"],
+	PageUp: ["⇞", "PgUp"],
+	PageDown: ["⇟", "PgDn"],
+	"+": ["+", "Plus"]
+};
+/**
+* Formats a binding the way its platform writes shortcuts: `⇧⌘S` on a Mac,
+* `Ctrl+Shift+S` elsewhere. The steps of a sequence are set apart by a space.
+*/
+function formatBinding(binding, platform = detectPlatform()) {
+	return stepsOf(binding).map((step) => formatChord(step, platform)).join(" ");
+}
+/**
+* Splits a binding into display tokens for rendering `<kbd>` elements: one
+* per key of a chord, one per step of a sequence.
+*/
+function bindingTokens(binding, platform = detectPlatform()) {
+	if (isSequence(binding)) return binding.sequence.map((step) => formatChord(step, platform));
+	return chordTokens(binding, platform);
+}
+function formatChord(chord, platform) {
+	return chordTokens(chord, platform).join(platform === "mac" ? "" : "+");
+}
+function chordTokens(chord, platform) {
+	const parsed = parseChord(chord, platform);
+	if (!parsed) return [chord];
+	const held = [
+		parsed.ctrl,
+		parsed.alt,
+		parsed.shift,
+		parsed.meta
+	];
+	return [...MODIFIER_LABELS[platform].filter((_, index) => held[index]), KEY_LABELS[parsed.key]?.[platform === "mac" ? 0 : 1] ?? parsed.key];
+}
+/**
+* The `aria-keyshortcuts` value for a chord, as in `"Meta+K"`. Empty for a
+* sequence, which the attribute cannot express, and for a chord that cannot be read.
+*/
+function ariaKeyShortcuts(binding, platform = detectPlatform()) {
+	const parsed = isSequence(binding) ? null : parseChord(binding, platform);
+	if (!parsed) return "";
+	return writeChord(parsed.key === "+" ? {
+		...parsed,
+		key: "Plus"
+	} : parsed);
+}
+//#endregion
+//#region src/keymap.ts
+/** Keymap: default bindings, and the user's overrides on top of them. */
+/** A signature that holds on every platform, so `Mod+S` and `Control+S` stay distinct. */
+const portable = (binding) => `${bindingSignature(binding, "mac")} ${bindingSignature(binding, "other")}`;
+var Keymap = class {
+	#defaults = /* @__PURE__ */ new Map();
+	#overrides = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Set();
+	#store;
+	#loaded = false;
+	constructor(store) {
+		this.#store = store;
+	}
+	/** Sets a command's default bindings. `null` leaves the command unbound. */
+	setDefault(id, input) {
+		const bindings = toBindings(input);
+		if (bindings.length === 0) this.#defaults.delete(id);
+		else this.#defaults.set(id, bindings);
+	}
+	/** Checks whether a command has an active user override. */
+	isOverridden(id) {
+		return this.#overrides.has(id);
+	}
+	/** The user's overrides, for a store or an export to write out. */
+	get overrides() {
+		return this.#overrides;
+	}
+	get(id) {
+		return this.#overrides.get(id) ?? this.#defaults.get(id) ?? [];
+	}
+	set(id, input) {
+		this.load();
+		const bindings = input === null ? [] : toBindings(input);
+		if (sameBindings(bindings, this.#defaults.get(id) ?? [])) {
+			if (!this.#overrides.delete(id)) return;
+		} else this.#overrides.set(id, bindings);
+		this.#changed();
+	}
+	reset(id) {
+		this.load();
+		if (id === void 0) {
+			if (this.#overrides.size === 0) return;
+			this.#overrides.clear();
+		} else if (!this.#overrides.delete(id)) return;
+		this.#changed();
+	}
+	/** Replaces every override and saves, as an import does. */
+	replace(overrides) {
+		this.#loaded = true;
+		this.#overrides = overrides;
+		this.#changed();
+	}
+	/**
+	* Takes the stored overrides, once: on the first mount, or before an edit
+	* made earlier, so the edit lands on top of them. Tells subscribers if they
+	* differ from the ones in memory, and returns whether they did.
+	*/
+	load() {
+		if (this.#loaded) return false;
+		this.#loaded = true;
+		const stored = this.#store?.read();
+		if (!stored) return false;
+		const changed = JSON.stringify([...stored]) !== JSON.stringify([...this.#overrides]);
+		this.#overrides = stored;
+		if (changed) this.#notify();
+		return changed;
+	}
+	/** Subscribes to keymap changes. Returns an unsubscribe function. */
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+	#changed() {
+		this.#store?.write(this.#overrides);
+		this.#notify();
+	}
+	#notify() {
+		for (const listener of this.#listeners) listener();
+	}
+};
+/** Same bindings in the same order; the first is the one shortcuts display. */
+function sameBindings(a, b) {
+	return a.length === b.length && a.every((binding, index) => portable(binding) === portable(b[index]));
+}
+//#endregion
+//#region src/persist.ts
+/** Keeping a keymap between visits: Web Storage, and export and import as JSON. */
+const VERSION = 1;
+/**
+* Keeps user overrides in Web Storage under `key`. `storage` is only called in
+* the browser; return `sessionStorage` or an object of your own to keep them
+* somewhere else.
+*
+* @example
+* ```ts
+* createCommands(definitions, { persist: webStorage("my-app.keys") });
+* ```
+*/
+function webStorage(key = "inklu.keys", storage = () => localStorage) {
+	const open = () => {
+		try {
+			return storage();
+		} catch {
+			return null;
+		}
+	};
+	return {
+		read() {
+			const area = open();
+			if (!area) return null;
+			try {
+				const raw = area.getItem(key);
+				return raw ? parseKeymap(JSON.parse(raw)) : /* @__PURE__ */ new Map();
+			} catch {
+				return null;
+			}
+		},
+		write(overrides) {
+			try {
+				if (overrides.size === 0) open()?.removeItem(key);
+				else open()?.setItem(key, JSON.stringify(serializeKeymap(overrides)));
+			} catch {}
+		}
+	};
+}
+/** A registry's user overrides as JSON-safe data, for your own storage or another device. */
+function exportKeymap(commands) {
+	return serializeKeymap(keymapOf(commands).overrides);
+}
+/**
+* Replaces a registry's user overrides with exported data, and saves them.
+* Data in another format changes nothing.
+*/
+function importKeymap(commands, data) {
+	const overrides = parseKeymap(data);
+	if (overrides) keymapOf(commands).replace(overrides);
+}
+function keymapOf({ keymap }) {
+	if (keymap instanceof Keymap) return keymap;
+	throw new TypeError("[@inklu/keys] not a registry made by createCommands");
+}
+function serializeKeymap(overrides) {
+	return {
+		version: VERSION,
+		overrides: Object.fromEntries(Array.from(overrides, ([id, bindings]) => [id, bindings.map((binding) => isSequence(binding) ? [...binding.sequence] : binding)]))
+	};
+}
+/** The overrides in stored data, or `null` for data in another format. */
+function parseKeymap(data) {
+	const stored = isObject(data) && data.version === VERSION ? data.overrides : void 0;
+	if (stored === void 0 || !isObject(stored)) return null;
+	const overrides = /* @__PURE__ */ new Map();
+	for (const [id, value] of Object.entries(stored)) {
+		if (!Array.isArray(value)) continue;
+		const bindings = value.map(parseStoredBinding).filter((binding) => binding !== null);
+		if (bindings.length > 0 || value.length === 0) overrides.set(id, bindings);
+	}
+	return overrides;
+}
+/** A stored chord (a string) or sequence (a list of them), or `null` if it cannot be read. */
+function parseStoredBinding(value) {
+	if (typeof value === "string") return isChord(value) ? value : null;
+	if (!Array.isArray(value)) return null;
+	const steps = [];
+	for (const step of value) {
+		if (typeof step !== "string" || !isChord(step)) return null;
+		steps.push(step);
+	}
+	const [first, ...rest] = steps;
+	if (first === void 0) return null;
+	return rest.length === 0 ? first : { sequence: steps };
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/rebind.ts
+const NO_STEPS = [];
+/**
+* Creates a rebinder for recording a command's keys. While it records, no
+* command runs. Escape cancels, Backspace removes the shortcut (or the last
+* step of a sequence), and Enter finishes a sequence.
+*
+* @example
+* ```ts
+* const rebinder = createRebinder(commands, "palette.open", {
+*   onRecord: (binding, conflicts) => showConflicts(conflicts),
+* });
+* rebinder.start();
+* ```
+*/
+function createRebinder(registry, id, options = {}) {
+	const listeners = /* @__PURE__ */ new Set();
+	let state = {
+		recording: false,
+		binding: null,
+		steps: NO_STEPS,
+		conflicts: []
+	};
+	let release = null;
+	const set = (next) => {
+		state = next;
+		for (const listener of listeners) listener();
+	};
+	/** Gives the keyboard back. */
+	const end = () => {
+		release?.();
+		release = null;
+	};
+	const record = (binding) => {
+		end();
+		const conflicts = binding ? registry.conflicts(binding, {
+			ignore: id,
+			scope: registry.get(id)?.scope
+		}) : [];
+		const blocked = options.rejectConflicts === true && conflicts.length > 0;
+		if (options.apply !== false && !blocked) registry.keymap.set(id, binding);
+		set({
+			recording: false,
+			binding,
+			steps: NO_STEPS,
+			conflicts
+		});
+		options.onRecord?.(binding, conflicts);
+	};
+	const cancel = () => {
+		if (!state.recording) return;
+		end();
+		set({
+			...state,
+			recording: false,
+			steps: NO_STEPS
+		});
+		options.onCancel?.();
+	};
+	const commit = () => {
+		const [first, ...rest] = state.steps;
+		if (!state.recording || first === void 0) return;
+		record(rest.length === 0 ? first : { sequence: state.steps });
+	};
+	const onKey = (event, chord) => {
+		event.preventDefault();
+		event.stopPropagation();
+		if (event.repeat) return;
+		const bare = !event.ctrlKey && !event.altKey && !event.shiftKey && !event.metaKey;
+		if (bare && event.key === "Escape") return cancel();
+		if (bare && (event.key === "Backspace" || event.key === "Delete")) return state.steps.length === 0 ? record(null) : set({
+			...state,
+			steps: state.steps.slice(0, -1)
+		});
+		if (options.sequence && bare && event.key === "Enter") return commit();
+		if (chord === null) return;
+		if (options.sequence) set({
+			...state,
+			steps: [...state.steps, chord]
+		});
+		else record(chord);
+	};
+	return {
+		start: () => {
+			if (state.recording) return;
+			release = registry.capture(onKey);
+			set({
+				recording: true,
+				binding: null,
+				steps: NO_STEPS,
+				conflicts: []
+			});
+		},
+		cancel,
+		commit,
+		get state() {
+			return state;
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		destroy: () => {
+			end();
+			if (state.recording) set({
+				...state,
+				recording: false,
+				steps: NO_STEPS
+			});
+		}
+	};
+}
+/**
+* Whether commands in two scopes can be live together, so their bindings can
+* collide: a global or `"*"` command overlaps every scope, and two named
+* scopes only when they are the same.
+*/
+function scopesOverlap(a, b) {
+	if (a === void 0 || b === void 0) return true;
+	if (a === "*" || b === "*") return true;
+	return a === b;
+}
+/** Stack managing active scopes and command reachability. */
+var ScopeStack = class {
+	#entries = [];
+	#listeners = /* @__PURE__ */ new Set();
+	/** Activates a scope until the returned disposal function is called. */
+	push(name, options = {}) {
+		const entry = {
+			name,
+			exclusive: options.exclusive === true
+		};
+		this.#entries.push(entry);
+		this.#notify();
+		return () => {
+			const index = this.#entries.indexOf(entry);
+			if (index === -1) return;
+			this.#entries.splice(index, 1);
+			this.#notify();
+		};
+	}
+	/**
+	* Whether the keys of commands in `scope` are live: the scope is open and
+	* no `exclusive` scope above it has claimed the keyboard.
+	*/
+	isActive(scope) {
+		if (scope === "*") return true;
+		const barrier = this.#barrierIndex();
+		if (barrier === -1) return this.isOpen(scope);
+		return scope !== void 0 && this.depth(scope) >= barrier;
+	}
+	/** Whether `scope` is open at all, barriers aside. This is what a direct `run()` checks. */
+	isOpen(scope) {
+		return scope === void 0 || scope === "*" || this.depth(scope) !== -1;
+	}
+	/** How far up the stack `scope` was last opened, or `-1` for a global or closed one. */
+	depth(scope) {
+		if (scope === void 0 || scope === "*") return -1;
+		for (let index = this.#entries.length - 1; index >= 0; index--) if (this.#entries[index]?.name === scope) return index;
+		return -1;
+	}
+	/** Clears all active scopes. */
+	clear() {
+		if (this.#entries.length === 0) return;
+		this.#entries = [];
+		this.#notify();
+	}
+	/** Subscribes to scope stack changes. Returns an unsubscribe function. */
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+	#barrierIndex() {
+		for (let index = this.#entries.length - 1; index >= 0; index--) if (this.#entries[index]?.exclusive) return index;
+		return -1;
+	}
+	#notify() {
+		for (const listener of this.#listeners) listener();
+	}
+};
+//#endregion
+//#region src/audit.ts
+/** Development-only warnings about default bindings that cannot work as written. */
+const chords = (list) => new Set(list.split(" "));
+const RESERVED = {
+	mac: chords("Meta+N Meta+T Meta+W Meta+Q Meta+H Meta+M Meta+Tab Meta+Space Shift+Meta+N Shift+Meta+T Shift+Meta+W Shift+Meta+Q Shift+Meta+Tab Shift+Meta+3 Shift+Meta+4 Shift+Meta+5 Control+Tab Control+Shift+Tab Control+Meta+Q"),
+	other: chords("Control+N Control+T Control+W Control+Shift+N Control+Shift+T Control+Shift+W Control+Tab Control+Shift+Tab Control+PageUp Control+PageDown Control+F4 Alt+F4 Alt+Tab Alt+Shift+Tab Alt+Space Control+Alt+Tab Control+Alt+Delete")
+};
+/** Whether any step of a binding is a chord the browser or OS reserves on a platform. */
+function isReserved(binding, platform) {
+	return (parseBinding(binding, platform) ?? []).some((chord) => platform === "mac" ? RESERVED.mac.has(writeChord(chord)) : chord.meta || RESERVED.other.has(writeChord(chord)));
+}
+const platformName = (platform) => platform === "mac" ? "macOS" : "Windows and Linux";
+/** A binding as the app wrote it, which is what there is to search the code for. */
+const written = (binding) => stepsOf(binding).join(" ");
+/**
+* Warns about bad syntax, keys the platform keeps or types with, unknown
+* overrides and collisions. Called behind a `NODE_ENV` check, so a production
+* build drops this module.
+*/
+function auditRegistry(source) {
+	const said = /* @__PURE__ */ new Set();
+	const warn = (message) => {
+		if (said.has(message)) return;
+		said.add(message);
+		console.warn(`[@inklu/keys] ${message}`);
+	};
+	/** Reserved bindings, and the platforms each is reserved on. */
+	const reserved = /* @__PURE__ */ new Map();
+	for (const platform of source.platforms) {
+		for (const id of source.ids) for (const binding of source.bindings(id, platform)) {
+			warnAboutBinding(id, binding, platform, warn);
+			if (!isReserved(binding, platform)) continue;
+			const subject = `"${id}" binds "${written(binding)}"`;
+			reserved.set(subject, (reserved.get(subject) ?? /* @__PURE__ */ new Set()).add(platformName(platform)));
+		}
+		warnAboutConflicts(source, platform, warn);
+	}
+	for (const [subject, platforms] of reserved) warn(`${subject}, which the browser or operating system keeps for itself on ${[...platforms].join(" and ")}, so it may never reach the page.`);
+	warnAboutUnknownOverrides(source, warn);
+}
+function warnAboutBinding(id, binding, platform, warn) {
+	const { errors, warnings } = validateBinding(binding);
+	if (errors.length > 0) {
+		warn(`"${id}" has an unrecognized binding "${written(binding)}", so it never fires. ${errors.join("; ")}.`);
+		return;
+	}
+	if (warnings.length > 0) warn(`"${id}" binds "${written(binding)}". ${warnings.join(" ")}`);
+	const held = (parseBinding(binding, platform) ?? []).filter((step) => step.ctrl && step.alt);
+	if (held.length === 0) return;
+	if (platform === "mac") warn(`"${id}" binds "${written(binding)}". Control+Option is the VoiceOver modifier on macOS, so screen reader users cannot press it.`);
+	else if (held.some((step) => typesCharacter({
+		...step,
+		ctrl: false,
+		alt: false
+	}))) warn(`"${id}" binds "${written(binding)}". Control+Alt is AltGr on many Windows and Linux keyboard layouts, where it types a character instead. Give those platforms other keys with { mac, other }.`);
+}
+function warnAboutConflicts(source, platform, warn) {
+	const seen = /* @__PURE__ */ new Map();
+	const visited = [];
+	for (const id of source.ids) {
+		const scope = source.scope(id);
+		for (const binding of source.bindings(id, platform)) {
+			for (const other of visited) {
+				if (other.id === id || !scopesOverlap(other.scope, scope)) continue;
+				if (!isPrefixCollision(other.binding, binding, platform)) continue;
+				const [short, long] = stepsOf(other.binding).length < stepsOf(binding).length ? [other, {
+					id,
+					binding
+				}] : [{
+					id,
+					binding
+				}, other];
+				warn(`prefix collision: ${written(short.binding)} ("${short.id}") is a prefix of ${written(long.binding)} ("${long.id}"), so the shorter binding fires on the way to the longer one.`);
+			}
+			visited.push({
+				id,
+				scope,
+				binding
+			});
+			const key = `${scope ?? ""}::${bindingSignature(binding, platform)}`;
+			const owner = seen.get(key);
+			if (owner === void 0) {
+				seen.set(key, id);
+				continue;
+			}
+			warn(`shadowed binding: "${id}" and "${owner}" share ${written(binding)} in the same scope, so "${id}" takes the key whenever both have a handler.`);
+		}
+	}
+}
+/** Catches ids in `options.bindings` that TypeScript could not, as in plain JS. */
+function warnAboutUnknownOverrides(source, warn) {
+	if (!source.overrides) return;
+	const known = new Set(source.ids);
+	const unknown = Object.keys(source.overrides).filter((id) => !known.has(id));
+	if (unknown.length > 0) warn(`bindings override ${unknown.map((id) => `"${id}"`).join(", ")}, which ${unknown.length === 1 ? "is not a registered command" : "are not registered commands"}.`);
+}
+//#endregion
+//#region src/keys.ts
+/** The one keyboard listener: matches a keypress to bindings and runs the command that wins it. */
+/** How long a sequence waits for its next step, in milliseconds. */
+const SEQUENCE_TIMEOUT = 1e3;
+var KeyListener = class {
+	#host;
+	#attached = false;
+	#bound = null;
+	/** Whoever has taken the keyboard, the most recent last. See `capture`. */
+	#captures = [];
+	/** The keypress a capture used up: released in the same event, it must not run a chord. */
+	#spent = null;
+	constructor(host) {
+		this.#host = host;
+	}
+	/** Starts listening. A no-op on the server. */
+	attach() {
+		if (this.#attached || typeof document === "undefined") return;
+		this.#attached = true;
+		document.addEventListener("keydown", this.#onKeyDown);
+	}
+	/** Stops listening and abandons half-typed sequences. */
+	detach() {
+		if (this.#attached) document.removeEventListener("keydown", this.#onKeyDown);
+		this.#attached = false;
+		this.refresh();
+	}
+	/** Stops listening for good, dropping the captures too. */
+	destroy() {
+		while (this.#captures.length > 0) this.#release(this.#captures[0]);
+		this.detach();
+	}
+	/** Whether something has taken the keyboard, so no command's keys are live. */
+	get captured() {
+		return this.#captures.length > 0;
+	}
+	/** Hands every keypress to `onKey` until released, in the capture phase on the document. */
+	capture(onKey) {
+		if (typeof document === "undefined") return () => {};
+		this.#captures.push(onKey);
+		if (this.#captures.length === 1) document.addEventListener("keydown", this.#onCapture, true);
+		return () => this.#release(onKey);
+	}
+	#release(onKey) {
+		const index = this.#captures.lastIndexOf(onKey);
+		if (index === -1) return;
+		this.#captures.splice(index, 1);
+		if (this.#captures.length === 0) document.removeEventListener("keydown", this.#onCapture, true);
+	}
+	/** Bindings or the platform changed: re-read them. Half-typed sequences start over. */
+	refresh() {
+		this.#bound = null;
+	}
+	#bindings() {
+		if (this.#bound) return this.#bound;
+		const platform = this.#host.platform();
+		const bound = [];
+		this.#host.ids().forEach((id, order) => {
+			for (const binding of this.#host.bindings(id)) {
+				const steps = parseBinding(binding, platform);
+				if (steps) bound.push({
+					id,
+					order,
+					binding,
+					steps,
+					matched: 0,
+					at: 0
+				});
+			}
+		});
+		this.#bound = bound;
+		return bound;
+	}
+	#onCapture = (event) => {
+		const onKey = this.#captures.at(-1);
+		if (!onKey || isComposing(event)) return;
+		this.#spent = event;
+		onKey(event, readChord(event, this.#host.platform()));
+	};
+	#onKeyDown = (event) => {
+		if (event === this.#spent) {
+			this.#spent = null;
+			return;
+		}
+		if (event.defaultPrevented || isComposing(event) || this.captured) return;
+		if (isModifierKey(event.key)) return;
+		const platform = this.#host.platform();
+		const typing = isTyping(event);
+		const now = Date.now();
+		const chords = [];
+		const sequences = [];
+		let continued = false;
+		let prevent = false;
+		for (const bound of this.#bindings()) {
+			const definition = this.#host.definition(bound.id);
+			const first = bound.steps[0];
+			if (!definition || !first || !this.#host.reachable(bound.id)) continue;
+			if (typing && (definition.ignoreInputs ?? !isBareEscape(bound))) continue;
+			if (bound.steps.length === 1) {
+				if (matchesChord(event, first, platform)) chords.push(bound);
+				continue;
+			}
+			if (event.repeat) continue;
+			const matched = now - bound.at > SEQUENCE_TIMEOUT ? 0 : bound.matched;
+			const expected = bound.steps[matched];
+			let reached = 0;
+			if (expected && matchesChord(event, expected, platform)) reached = matched + 1;
+			else if (matched > 0 && matchesChord(event, first, platform)) reached = 1;
+			bound.matched = reached === bound.steps.length ? 0 : reached;
+			bound.at = now;
+			if (reached === 0) continue;
+			if (reached === bound.steps.length) sequences.push(bound);
+			else {
+				const step = bound.steps[reached - 1];
+				if (!typing || step?.ctrl || step?.meta) prevent = true;
+				if (reached > 1) continued = true;
+			}
+		}
+		const candidates = sequences.length > 0 ? sequences : continued ? [] : chords;
+		let winner;
+		for (const bound of candidates) if (!winner || this.#outranks(bound, winner)) winner = bound;
+		if (!winner) {
+			if (prevent) event.preventDefault();
+			return;
+		}
+		event.preventDefault();
+		if (!event.repeat) this.#host.run(winner.id, event, winner.binding);
+	};
+	#outranks(a, b) {
+		const depth = this.#host.depth(a.id) - this.#host.depth(b.id);
+		return depth === 0 ? a.order > b.order : depth > 0;
+	}
+};
+/**
+* Whether a keydown belongs to an IME composition. Some engines report it
+* only as `keyCode` 229 or the key `Process`.
+*/
+function isComposing(event) {
+	return event.isComposing || event.keyCode === 229 || event.key === "Process";
+}
+/** A chord of the Escape key alone: the one key a text field does not keep. */
+function isBareEscape(bound) {
+	const [step] = bound.steps;
+	return bound.steps.length === 1 && step?.key === "Escape" && !step.ctrl && !step.alt && !step.shift && !step.meta;
+}
+/** Whether a keypress lands in a field that takes text. */
+function isTyping(event) {
+	return event.composedPath().some(isTextEntry);
+}
+/** ARIA roles of widgets that take typed keys the way their native counterparts do. */
+const TEXT_ENTRY_ROLES = /* @__PURE__ */ new Set([
+	"textbox",
+	"searchbox",
+	"combobox",
+	"spinbutton",
+	"slider"
+]);
+/** Input types that take no typed keys, so a focused one keeps nothing from a command. */
+const KEYLESS_INPUTS = /* @__PURE__ */ new Set([
+	"button",
+	"submit",
+	"reset",
+	"image",
+	"checkbox",
+	"radio",
+	"color",
+	"file",
+	"hidden"
+]);
+function isTextEntry(node) {
+	if (!(node instanceof HTMLElement)) return false;
+	if (node instanceof HTMLInputElement) return !KEYLESS_INPUTS.has(node.type.toLowerCase());
+	return node instanceof HTMLTextAreaElement || node instanceof HTMLSelectElement || !["false", null].includes(node.getAttribute("contenteditable")) || TEXT_ENTRY_ROLES.has(node.getAttribute("role") ?? "");
+}
+//#endregion
+//#region src/registry.ts
+/** Command registry: what an app can do, which keys do it, and where each is live. */
+const SSR_PLATFORM = "other";
+var CommandRegistry = class {
+	#definitions = /* @__PURE__ */ new Map();
+	/** Handlers attached per command, the most recent last. */
+	#handlers = /* @__PURE__ */ new Map();
+	#keymap;
+	#scopes = new ScopeStack();
+	#keys;
+	#options;
+	#listeners = /* @__PURE__ */ new Set();
+	#snapshot = null;
+	/** What the snapshot is behind on: who is reachable, or the bindings too. */
+	#stale = "bindings";
+	#serverSnapshot = null;
+	#mounts = 0;
+	#hydrated = false;
+	#singleKeys;
+	constructor(definitions, options = {}) {
+		this.#options = options;
+		this.#singleKeys = options.singleKeyShortcuts !== false;
+		this.#keymap = new Keymap(options.persist);
+		for (const id in definitions) this.#definitions.set(id, definitions[id]);
+		this.#setDefaults();
+		this.#keys = new KeyListener({
+			ids: () => [...this.#definitions.keys()],
+			definition: (id) => this.#definitions.get(id),
+			bindings: (id) => this.#bindings(id),
+			reachable: (id) => this.#reachable(id),
+			depth: (id) => this.#scopes.depth(this.#definitions.get(id)?.scope),
+			platform: () => this.#platform(),
+			run: (id, event, binding) => this.#execute(id, {
+				source: "keyboard",
+				event,
+				binding
+			})
+		});
+		this.#keymap.subscribe(() => this.#bindingsChanged());
+		this.#scopes.subscribe(() => this.#invalidate("reachable"));
+		if (process.env.NODE_ENV !== "production") auditRegistry({
+			ids: [...this.#definitions.keys()],
+			scope: (id) => this.#definitions.get(id)?.scope,
+			bindings: (id, platform) => this.#defaultBindings(id, platform),
+			platforms: options.platform ? [options.platform] : ["mac", "other"],
+			overrides: options.bindings
+		});
+	}
+	get keymap() {
+		return this.#keymap;
+	}
+	get(id) {
+		return this.#snapshots().index.get(id);
+	}
+	list() {
+		return this.#snapshots().list;
+	}
+	serverList() {
+		if (this.#serverSnapshot) return this.#serverSnapshot;
+		const platform = this.#options.platform ?? SSR_PLATFORM;
+		const singleKeys = this.#options.singleKeyShortcuts !== false;
+		this.#serverSnapshot = Array.from(this.#definitions, ([id, definition]) => {
+			const bindings = this.#defaultBindings(id, platform).filter((binding) => singleKeys || !isSingleKeyBinding(binding));
+			const global = definition.scope === void 0 || definition.scope === "*";
+			return describeCommand(id, definition, bindings, platform, {
+				reachable: definition.run !== void 0 && global,
+				overridden: false
+			});
+		});
+		return this.#serverSnapshot;
+	}
+	run(id, options = {}) {
+		if (this.whyNotRun(id) !== null) return false;
+		this.#execute(id, {
+			source: options.source ?? "api",
+			event: options.event
+		});
+		return true;
+	}
+	whyNotRun(id) {
+		const definition = this.#definitions.get(id);
+		if (!definition) return "unknown";
+		if (!this.#handler(id)) return "unhandled";
+		return this.#scopes.isOpen(definition.scope) ? null : "out-of-scope";
+	}
+	handle(id, run) {
+		if (!this.#definitions.has(id)) return () => {};
+		let handlers = this.#handlers.get(id);
+		if (!handlers) {
+			handlers = [];
+			this.#handlers.set(id, handlers);
+		}
+		const had = this.#handler(id) !== void 0;
+		handlers.push(run);
+		if (!had) this.#invalidate("reachable");
+		let disposed = false;
+		return () => {
+			if (disposed) return;
+			disposed = true;
+			const index = handlers.lastIndexOf(run);
+			if (index !== -1) handlers.splice(index, 1);
+			if (this.#handler(id) === void 0) this.#invalidate("reachable");
+		};
+	}
+	pushScope(name, options) {
+		return this.#scopes.push(name, options);
+	}
+	capture(onKey) {
+		const release = this.#keys.capture(onKey);
+		this.#invalidate("reachable");
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			release();
+			this.#invalidate("reachable");
+		};
+	}
+	conflicts(binding, options = {}) {
+		const platform = this.#platform();
+		const candidates = toBindings(binding);
+		const signatures = new Set(candidates.map((entry) => bindingSignature(entry, platform)));
+		const conflicts = [];
+		for (const [id, { scope }] of this.#definitions) {
+			if (id === options.ignore || !scopesOverlap(scope, options.scope)) continue;
+			for (const existing of this.#bindings(id)) {
+				const kind = signatures.has(bindingSignature(existing, platform)) ? "exact" : candidates.some((candidate) => isPrefixCollision(candidate, existing, platform)) ? "prefix" : null;
+				if (kind === null) continue;
+				conflicts.push({
+					kind,
+					id,
+					binding: existing,
+					display: formatBinding(existing, platform),
+					scope
+				});
+			}
+		}
+		return conflicts;
+	}
+	get singleKeyShortcuts() {
+		return this.#singleKeys;
+	}
+	setSingleKeyShortcuts(enabled) {
+		if (this.#singleKeys === enabled) return;
+		this.#singleKeys = enabled;
+		this.#bindingsChanged();
+	}
+	mount() {
+		this.#mounts++;
+		if (this.#mounts === 1) {
+			const rendered = this.#platform();
+			this.#hydrated = true;
+			const moved = this.#platform() !== rendered;
+			if (moved) this.#setDefaults();
+			this.#keys.attach();
+			if (!this.#keymap.load() && moved) this.#bindingsChanged();
+		}
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			if (this.#mounts === 0) return;
+			this.#mounts--;
+			if (this.#mounts === 0) this.#keys.detach();
+		};
+	}
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+	destroy() {
+		this.#mounts = 0;
+		this.#keys.destroy();
+		this.#definitions.clear();
+		this.#handlers.clear();
+		this.#serverSnapshot = null;
+		this.#invalidate("bindings");
+		this.#listeners.clear();
+		this.#scopes.clear();
+	}
+	/** The handler that runs: the one attached last, else the definition's own. */
+	#handler(id) {
+		return this.#handlers.get(id)?.at(-1) ?? this.#definitions.get(id)?.run;
+	}
+	#reachable(id) {
+		if (this.#keys.captured || !this.#handler(id)) return false;
+		return this.#scopes.isActive(this.#definitions.get(id)?.scope);
+	}
+	/** Bindings in effect: the keymap's, minus single-key ones while those are switched off. */
+	#bindings(id) {
+		const bindings = this.#keymap.get(id);
+		if (this.#singleKeys) return bindings;
+		return bindings.filter((binding) => !isSingleKeyBinding(binding));
+	}
+	/**
+	* A command's default bindings on a platform. An `options.bindings` entry
+	* wins over the definition's `keys`, and a `null` one means unbound.
+	*/
+	#defaultBindings(id, platform) {
+		const override = this.#options.bindings?.[id];
+		return toBindings(keysFor(override === void 0 ? this.#definitions.get(id)?.keys : override, platform));
+	}
+	/** Hands the keymap every command's defaults for the platform in effect. */
+	#setDefaults() {
+		const platform = this.#platform();
+		for (const id of this.#definitions.keys()) this.#keymap.setDefault(id, this.#defaultBindings(id, platform));
+	}
+	#execute(id, context) {
+		const run = this.#handler(id);
+		if (!run) return;
+		const full = {
+			id,
+			...context,
+			commands: this
+		};
+		this.#options.onRun?.(full);
+		const report = (error) => console.error(`[@inklu/keys] "${id}" failed`, error);
+		try {
+			const result = run(full);
+			if (result instanceof Promise) result.catch(report);
+		} catch (error) {
+			report(error);
+		}
+	}
+	#bindingsChanged() {
+		this.#keys.refresh();
+		this.#invalidate("bindings");
+	}
+	#platform() {
+		return this.#options.platform ?? (this.#hydrated ? detectPlatform() : SSR_PLATFORM);
+	}
+	/**
+	* The commands as they are now. A command that did not change keeps its
+	* object, and the list keeps its own while none did, so a subscriber can
+	* tell by identity whether it has anything to do.
+	*/
+	#snapshots() {
+		const previous = this.#snapshot;
+		if (previous && !this.#stale) return previous;
+		const kept = this.#stale === "reachable" ? previous?.index : void 0;
+		const platform = this.#platform();
+		const list = [];
+		const index = /* @__PURE__ */ new Map();
+		let changed = !kept;
+		for (const [id, definition] of this.#definitions) {
+			const reachable = this.#reachable(id);
+			let command = kept?.get(id);
+			if (!command) command = describeCommand(id, definition, this.#bindings(id), platform, {
+				reachable,
+				overridden: this.#keymap.isOverridden(id)
+			});
+			else if (command.reachable !== reachable) {
+				command = {
+					...command,
+					reachable
+				};
+				changed = true;
+			}
+			list.push(command);
+			index.set(id, command);
+		}
+		this.#stale = null;
+		this.#snapshot = changed || !previous ? {
+			list,
+			index
+		} : previous;
+		return this.#snapshot;
+	}
+	#invalidate(stale) {
+		if (this.#stale !== "bindings") this.#stale = stale;
+		for (const listener of this.#listeners) listener();
+	}
+};
+function describeCommand(id, definition, source, platform, state) {
+	const bindings = [...source];
+	return {
+		id,
+		title: definition.title,
+		scope: definition.scope,
+		bindings,
+		display: bindings.map((binding) => formatBinding(binding, platform)),
+		tokens: bindings.map((binding) => bindingTokens(binding, platform)),
+		aria: bindings.map((binding) => ariaKeyShortcuts(binding, platform)).filter((value) => value.length > 0).join(" "),
+		...state
+	};
+}
+/**
+* Creates a command registry.
+*
+* @example
+* ```ts
+* export const commands = createCommands({
+*   "palette.open": { title: "Open command palette", keys: "Mod+K" },
+*   "nav.inbox": {
+*     title: "Go to inbox",
+*     keys: seq("G", "I"),
+*     run: () => router.navigate("/inbox"),
+*   },
+* });
+* ```
+*/
+function createCommands(definitions, options) {
+	return new CommandRegistry(definitions, options);
+}
+//#endregion
+export { webStorage as a, formatBinding as c, importKeymap as i, isSingleKeyBinding as l, createRebinder as n, ariaKeyShortcuts as o, exportKeymap as r, bindingTokens as s, createCommands as t, seq as u };