@inklu/keys 2.1.0 → 3.0.0

package/dist/src-B76YvObL.mjs

@@ -1,1687 +0,0 @@
-//#region src/chord.ts
-/** The platform this code runs on, as `navigator` reports it. `"linux"` where there is none. */
-function detectPlatform() {
-	if (typeof navigator === "undefined") return "linux";
-	const platform = `${navigator.platform} ${navigator.userAgent}`.toLowerCase();
-	if (platform.includes("mac")) return "mac";
-	return platform.includes("win") ? "windows" : "linux";
-}
-/**
-* Named keys with a place in the `Key` type, as `KeyboardEvent.key` spells
-* them. Any other name still works as a key; `validateChord` only remarks on it.
-*/
-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 PHYSICAL = /^\[([A-Za-z][A-Za-z0-9]*)\]$/;
-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"));
-}
-function isOneCharacter(key) {
-	return Array.from(key).length === 1;
-}
-/** 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);
-	}
-	const code = PHYSICAL.exec(key)?.[1];
-	if (code === void 0 && key.length > 1 && (key.startsWith("[") || key.endsWith("]"))) return "Invalid physical key: use a bracketed KeyboardEvent.code, such as [KeyS]";
-	return {
-		ctrl: held.has("Control"),
-		alt: held.has("Alt"),
-		shift: held.has("Shift"),
-		meta: held.has("Meta"),
-		...code === void 0 ? { key: keyName(key) } : { code }
-	};
-}
-/** 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;
-}
-/**
-* What is wrong with a chord (`errors`: it will never fire) and what merely
-* looks off (`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.key;
-	return {
-		errors: [],
-		warnings: key === void 0 || isOneCharacter(key) || FUNCTION_KEY.test(key) || NAMED_KEYS.some((name) => name === key) ? [] : [`Unknown key: '${key}'. Key names are KeyboardEvent.key values, such as Escape.`]
-	};
-}
-/**
-* Writes a parsed chord back as text, modifiers in canonical order. Given a
-* platform it prefers `Mod`, which is how a chord stays portable when it is
-* stored and read back on another machine.
-*/
-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.code === void 0 ? chord.key ?? "" : `[${chord.code}]`);
-	return parts.join("+");
-}
-/**
-* Whether a chord types a character when pressed: one character, or a letter,
-* digit or punctuation key by position, with no Control, Alt or Meta. Shift
-* does not count as a modifier here: `Shift+A` still types a character.
-*/
-function typesCharacter(chord) {
-	if (chord.ctrl || chord.alt || chord.meta) return false;
-	return isOneCharacter(chord.key ?? keyAtCode(chord.code ?? "") ?? "");
-}
-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);
-}
-/**
-* AltGr types a third character on many layouts, and Windows reports it as
-* Control+Alt. While it is down those two flags say nothing about intent.
-*/
-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 a `KeyboardEvent.code` sits on in the conventional (US) layout. */
-function keyAtCode(code) {
-	if (/^Key[A-Z]$/.test(code)) return code.slice(3);
-	if (/^Digit[0-9]$/.test(code)) return code.slice(5);
-	return code === "Space" ? code : PUNCTUATION_CODES[code];
-}
-/** `KeyboardEvent.key` values that name neither a character nor a key. */
-const NO_KEY = /* @__PURE__ */ new Set([
-	"",
-	"Dead",
-	"Unidentified",
-	"Process"
-]);
-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);
-/** A key known by name rather than by a character, such as `Enter`. */
-const isNamed = (key) => !isOneCharacter(key) && !NO_KEY.has(key);
-/**
-* The key at a keypress's position on the conventional layout, when position
-* may stand in for what the layout produced. That is when the layout produced
-* nothing a chord would name:
-*
-* - On the digit row, always: `Mod+1` is the first key of that row on AZERTY,
-*   which types `&` there, and `Shift+2` is `@` on a US keyboard.
-* - On a letter key, when it typed a character from another script (`ы` on a
-*   Russian keyboard still reaches `Mod+S`), or macOS Option turned the letter
-*   into something else.
-* - On a punctuation key, the same, and also while Shift or Alt is held, so
-*   `Shift+/` can be written by its base key.
-*
-* Never when the layout typed a Latin letter or the key has a name (that is
-* the key pressed), nor under AltGr (the user is typing a character).
-*/
-function positionKey(event, key, altGraph) {
-	if (altGraph || /^[A-Z]$/.test(key) || isNamed(key)) return void 0;
-	const code = event.code;
-	if (/^Digit[0-9]$/.test(code)) return code.slice(5);
-	if (LATIN_LETTER.test(key) && !event.altKey) return void 0;
-	if (/^Key[A-Z]$/.test(code)) return isAscii(key) ? void 0 : code.slice(3);
-	return isAscii(key) && !event.shiftKey && !event.altKey ? void 0 : PUNCTUATION_CODES[code];
-}
-/**
-* Whether a keypress is this chord.
-*
-* A physical chord (`[KeyK]`) compares the key's position and nothing else.
-* A logical one names what the key produced, and matches in one of two ways:
-*
-* 1. The key produced is the chord's key. For a symbol, the modifiers that
-*    were only there to type it need not be named: `?` is Shift+/ on a US
-*    keyboard and unshifted elsewhere, and `[` is Option+5 on a German Mac.
-* 2. The key's position stands in for it, where `positionKey` allows.
-*
-* The approach follows the matcher in TanStack Hotkeys (MIT).
-*/
-function matchesChord(event, chord, platform) {
-	const altGraph = hasAltGraph(event, platform);
-	if (altGraph && (chord.ctrl || chord.alt)) return false;
-	const alt = !altGraph && event.altKey;
-	const modifiersMatch = (typing) => (!altGraph && event.ctrlKey) === chord.ctrl && event.metaKey === chord.meta && (alt === chord.alt || typing && alt && platform === "mac") && (event.shiftKey === chord.shift || typing && event.shiftKey);
-	if (chord.code !== void 0) return event.code === chord.code && modifiersMatch(false);
-	const key = pressedKey(event);
-	if (key === chord.key) return modifiersMatch(isSymbol(key));
-	return positionKey(event, key, altGraph) === chord.key && modifiersMatch(false);
-}
-/**
-* The chord a keypress expresses, for recording a new shortcut, or `null` for
-* a keypress that is not one: a modifier on its own, or a key with no name.
-*
-* It is the inverse of `matchesChord`: what it records, the same keypress
-* matches. It writes the character the layout typed where a chord can name it
-* (`?`, not `Shift+/`), the key's position otherwise (`Mod+S` for Ctrl+ы), and
-* `Mod` for the primary modifier, so the chord works on the user's other
-* machines too.
-*/
-function readChord(event, platform) {
-	if (isModifierKey(event.key)) return null;
-	const pressed = pressedKey(event);
-	const altGraph = hasAltGraph(event, platform);
-	const position = positionKey(event, pressed, altGraph);
-	const key = altGraph || isNamed(pressed) || isAscii(pressed) || LATIN_LETTER.test(pressed) && !event.altKey || position === void 0 ? pressed : position;
-	if (NO_KEY.has(key)) return null;
-	const typed = key === pressed && isSymbol(key);
-	const alt = !altGraph && event.altKey;
-	const chord = writeChord({
-		ctrl: !altGraph && event.ctrlKey,
-		alt: alt && !(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 serializing. */
-/**
-* 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 plain chord: it fires on exactly the same keypress, and keeping it
-* a sequence gave it a different signature from the chord, so the two were
-* neither arbitrated nor reported as conflicting — both ran.
-*/
-function toBindings(input) {
-	if (input == null) return [];
-	const candidates = isList(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;
-}
-function isList(input) {
-	return Array.isArray(input);
-}
-/** Generates a normalized signature for binding comparison and conflict detection. */
-function bindingSignature(binding, platform) {
-	const steps = canonicalSteps(binding, platform);
-	return isSequence(binding) ? `seq:${steps.join(" ")}` : `chord:${steps.join(" ")}`;
-}
-/**
-* Whether one binding is a strict prefix of the other — chord `G` against
-* `G then I`, or `G then G` against `G then G then I`. The shorter binding
-* fires on the way to the longer one, so both run for a single intent.
-*/
-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, so equivalent chords compare equal. One that cannot be read stays as written. */
-function canonicalSteps(binding, platform = detectPlatform()) {
-	return stepsOf(binding).map((step) => {
-		const parsed = parseChord(step, platform);
-		return parsed ? writeChord(parsed) : step;
-	});
-}
-/**
-* Whether every step of a binding is a single printable character with no
-* Control, Alt or Meta — the "character key shortcuts" WCAG 2.1.4 lets users
-* turn off, since speech input and stray keypresses trigger them by accident.
-*/
-function isSingleKeyBinding(binding) {
-	return parseBinding(binding, "mac")?.every(typesCharacter) === true;
-}
-/** Converts a binding to a JSON-serializable format. */
-function serializeBinding(binding) {
-	return isSequence(binding) ? [...binding.sequence] : binding;
-}
-/** Deserializes a stored value into a valid binding, or `null` if invalid. */
-function deserializeBinding(value) {
-	if (typeof value === "string") {
-		const chord = value.trim();
-		return isChord(chord) ? chord : null;
-	}
-	if (!Array.isArray(value)) return null;
-	const steps = [];
-	for (const step of value) {
-		if (step === "") continue;
-		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 };
-}
-/** Validates a binding's syntax without logging warnings or errors. */
-function validateBinding(binding) {
-	const steps = stepsOf(binding);
-	if (steps.length === 0) return {
-		valid: false,
-		errors: ["Sequence has no steps"],
-		warnings: []
-	};
-	const results = steps.map(validateChord);
-	const errors = results.flatMap((result) => result.errors);
-	return {
-		valid: errors.length === 0,
-		errors,
-		warnings: results.flatMap((r) => r.warnings)
-	};
-}
-//#endregion
-//#region src/display.ts
-/** Platform-aware hotkey display formatting and accessibility attributes. */
-const MODIFIER_LABELS = {
-	symbols: [
-		"⌃",
-		"⌥",
-		"⇧",
-		"⌘"
-	],
-	mac: [
-		"Control",
-		"Option",
-		"Shift",
-		"Cmd"
-	],
-	windows: [
-		"Ctrl",
-		"Alt",
-		"Shift",
-		"Win"
-	],
-	linux: [
-		"Ctrl",
-		"Alt",
-		"Shift",
-		"Super"
-	]
-};
-const KEY_SYMBOLS = {
-	ArrowUp: "↑",
-	ArrowDown: "↓",
-	ArrowLeft: "←",
-	ArrowRight: "→",
-	Enter: "↵",
-	Escape: "Esc",
-	Backspace: "⌫",
-	Delete: "⌦",
-	Tab: "⇥",
-	Space: "␣"
-};
-/** Names for the keys whose character is hard to tell apart in running text. */
-const PUNCTUATION_NAMES = {
-	"`": "Backquote",
-	"\\": "Backslash",
-	"[": "Left Bracket",
-	"]": "Right Bracket",
-	",": "Comma",
-	"=": "Equal",
-	"-": "Minus",
-	".": "Period",
-	";": "Semicolon"
-};
-/** Formats a binding for display on the target platform (e.g. `⌘ K` or `Ctrl+K`). */
-function formatBinding(binding, options) {
-	if (isSequence(binding)) return binding.sequence.map((step) => formatChord(step, options)).join(" ");
-	return formatChord(binding, options);
-}
-/** Splits a binding into display tokens for rendering `<kbd>` elements. */
-function bindingTokens(binding, options) {
-	if (isSequence(binding)) return binding.sequence.map((step) => formatChord(step, options));
-	return chordTokens(binding, options);
-}
-function formatChord(chord, options) {
-	const spaced = usesModifierSymbols(options);
-	return chordTokens(chord, options).join(spaced ? " " : "+");
-}
-function usesModifierSymbols(options) {
-	return (options?.platform ?? detectPlatform()) === "mac" && options?.useSymbols !== false;
-}
-function chordTokens(chord, options) {
-	const platform = options?.platform ?? detectPlatform();
-	const parsed = parseChord(chord, platform);
-	if (!parsed) return [chord];
-	const labels = MODIFIER_LABELS[usesModifierSymbols(options) ? "symbols" : platform];
-	const held = [
-		parsed.ctrl,
-		parsed.alt,
-		parsed.shift,
-		parsed.meta
-	];
-	return [...labels.filter((_, index) => held[index]), keyLabel(parsed, options)];
-}
-function keyLabel(chord, options) {
-	const names = options?.useSymbols === false ? PUNCTUATION_NAMES : KEY_SYMBOLS;
-	const label = (key) => names[key] ?? key;
-	if (chord.code === void 0) return label(chord.key ?? "");
-	if (chord.code.startsWith("Numpad")) return `Numpad ${label(chord.code.slice(6)).replace(/([a-z])([A-Z])/g, "$1 $2")}`;
-	return label(keyAtCode(chord.code) ?? chord.code);
-}
-/**
-* Phrases a binding for a screen reader: `"Control+K"` for a chord,
-* `"G then I"` for a sequence. `aria-keyshortcuts` cannot express a sequence
-* (a space there means "or"), so this is how a sequence gets announced — put it
-* in visually hidden text or `aria-description`.
-*/
-function spokenBinding(binding, platform) {
-	return stepsOf(binding).map((step) => keyNames(step, platform) || step).join(" then ");
-}
-/** Generates an `aria-keyshortcuts` attribute string for a binding. */
-function ariaKeyShortcuts(binding, platform) {
-	return isSequence(binding) ? "" : keyNames(binding, platform);
-}
-/** A chord in key names, `Mod` resolved: `"Meta+K"`. Empty for one that cannot be read. */
-function keyNames(chord, platform = detectPlatform()) {
-	const parsed = parseChord(chord, platform);
-	if (!parsed) return "";
-	const key = parsed.key ?? keyAtCode(parsed.code ?? "") ?? parsed.code;
-	return writeChord({
-		...parsed,
-		key,
-		code: void 0
-	});
-}
-//#endregion
-//#region src/keys.ts
-/** The one keyboard listener: matches a keypress to bindings and runs the command that wins it. */
-const DEFAULT_SEQUENCE_TIMEOUT = 1e3;
-/** The longest delay `setTimeout` honours; a longer one fires at once. */
-const MAX_TIMER = 2 ** 31 - 1;
-const NO_PROGRESS = [];
-var KeyListener = class {
-	#host;
-	#target;
-	#attached = null;
-	#bound = null;
-	/** Whoever has taken the keyboard, the most recent last. See `capture`. */
-	#captures = [];
-	#spent = null;
-	#watchers = /* @__PURE__ */ new Set();
-	#progress = NO_PROGRESS;
-	#timer = null;
-	constructor(host, target) {
-		this.#host = host;
-		this.#target = target;
-	}
-	/** Starts listening. A no-op on the server. */
-	attach() {
-		if (this.#attached || typeof document === "undefined") return;
-		this.#attached = this.#target ?? document;
-		this.#attached.addEventListener("keydown", this.#onKeyDown);
-	}
-	/** Stops listening and abandons half-typed sequences. */
-	detach() {
-		this.#attached?.removeEventListener("keydown", this.#onKeyDown);
-		this.#attached = null;
-		this.refresh();
-	}
-	/** Stops listening for good, dropping the watchers and captures too. */
-	destroy() {
-		this.#watchers.clear();
-		for (let onKey = this.#captures.at(-1); onKey; onKey = this.#captures.at(-1)) this.#release(onKey);
-		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. See `Commands.capture`.
-	* A capture listens first, in the capture phase and on the whole document,
-	* and only for as long as there is one.
-	*/
-	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) return;
-		document.removeEventListener("keydown", this.#onCapture, true);
-	}
-	/** Bindings or the platform changed: re-read them. Half-typed sequences start over. */
-	refresh() {
-		this.#bound = null;
-		this.#publish();
-	}
-	/**
-	* Reachability changed. A sequence that became unreachable halfway through
-	* loses its progress: otherwise a scope that closed and reopened within
-	* the timeout would let the next key complete a sequence begun in a
-	* different context.
-	*/
-	prune() {
-		let changed = false;
-		for (const bound of this.#bound ?? []) {
-			if (bound.matched === 0 || this.#host.reachable(bound.id)) continue;
-			bound.matched = 0;
-			changed = true;
-		}
-		if (changed) this.#publish();
-	}
-	/** Half-typed sequences. Tracked only while something is watching. */
-	progress() {
-		return this.#progress;
-	}
-	/** Watches sequence progress. It is tracked, and timed, only while someone is watching. */
-	watch(listener) {
-		this.#watchers.add(listener);
-		if (this.#watchers.size === 1) this.#publish();
-		return () => {
-			this.#watchers.delete(listener);
-			if (this.#watchers.size === 0) this.#publish();
-		};
-	}
-	#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) continue;
-				const timeout = this.#host.definition(id)?.sequenceTimeout ?? DEFAULT_SEQUENCE_TIMEOUT;
-				bound.push({
-					id,
-					order,
-					binding,
-					steps,
-					timeout,
-					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 (isComposing(event) || this.captured) return;
-		if (this.#spent) {
-			if (event === this.#spent || event.repeat) return;
-			this.#spent = null;
-		}
-		if (isModifierKey(event.key)) return;
-		const platform = this.#host.platform();
-		const typing = isTyping(event, this.#target);
-		const now = Date.now();
-		const chords = [];
-		const sequences = [];
-		let continued = false;
-		let prevent = false;
-		let progressed = 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 ?? ignoresInputs(first))) continue;
-			if (bound.steps.length === 1) {
-				if (matchesChord(event, first, platform)) chords.push(bound);
-				continue;
-			}
-			if (event.repeat) continue;
-			const matched = now - bound.at > bound.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;
-			const next = reached === bound.steps.length ? 0 : reached;
-			if (next !== bound.matched) progressed = true;
-			bound.matched = next;
-			bound.at = now;
-			if (reached === 0) continue;
-			if (reached > 1) continued = true;
-			if (reached === bound.steps.length) {
-				sequences.push(bound);
-				continue;
-			}
-			const step = bound.steps[reached - 1];
-			if (!(typing && !step?.ctrl && !step?.meta) && definition.preventDefault !== false) prevent = true;
-		}
-		if (progressed) this.#publish();
-		if (continued) this.#spent = event;
-		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 && this.#host.definition(winner.id)?.preventDefault !== false) prevent = true;
-		if (prevent) event.preventDefault();
-		if (winner) 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;
-	}
-	#publish = () => {
-		if (this.#timer !== null) clearTimeout(this.#timer);
-		this.#timer = null;
-		const progress = [];
-		let expires = null;
-		if (this.#watchers.size > 0) {
-			const now = Date.now();
-			for (const bound of this.#bound ?? []) {
-				if (bound.matched === 0 || !isSequence(bound.binding)) continue;
-				const deadline = bound.at + bound.timeout;
-				if (now > deadline) continue;
-				expires = expires === null ? deadline : Math.min(expires, deadline);
-				progress.push({
-					id: bound.id,
-					binding: bound.binding,
-					matched: bound.matched
-				});
-			}
-		}
-		const wait = expires === null ? Infinity : Math.max(0, expires - Date.now()) + 1;
-		if (wait < MAX_TIMER) this.#timer = setTimeout(this.#publish, wait);
-		if (progress.length === this.#progress.length && progress.every((entry, index) => {
-			const other = this.#progress[index];
-			return other?.binding === entry.binding && other.matched === entry.matched;
-		})) return;
-		this.#progress = progress.length === 0 ? NO_PROGRESS : progress;
-		for (const watcher of this.#watchers) watcher();
-	};
-};
-/**
-* A keydown mid-composition belongs to the IME — confirming a kana or pinyin
-* candidate must not also fire whatever the raw key is bound to. Older
-* engines report composition only as `keyCode` 229 or the key `Process`.
-*/
-function isComposing(event) {
-	return event.isComposing || event.keyCode === 229 || event.key === "Process";
-}
-/**
-* Whether a binding stays quiet while the user is typing, when its command
-* does not say: chords holding Control or Meta and bare `Escape` still fire
-* inside a text field, everything else would hijack a typed character.
-*/
-function ignoresInputs(step) {
-	return !(step.ctrl || step.meta || step.key === "Escape" || step.code === "Escape");
-}
-/**
-* Whether a keypress lands in a field that takes text. `host` is the element
-* the listener itself sits on, which never counts: keys bound on an editor
-* are meant for that editor.
-*/
-function isTyping(event, host) {
-	return event.composedPath().some((node) => node !== host && isTextEntry(node));
-}
-function isTextEntry(node) {
-	if (typeof HTMLElement === "undefined" || !(node instanceof HTMLElement)) return false;
-	if (node instanceof HTMLInputElement) {
-		const type = node.type.toLowerCase();
-		return type !== "button" && type !== "submit" && type !== "reset";
-	}
-	return node instanceof HTMLTextAreaElement || node instanceof HTMLSelectElement || !["false", null].includes(node.getAttribute("contenteditable"));
-}
-//#endregion
-//#region src/rebind.ts
-/** Controller for recording and applying hotkey rebindings. */
-const NO_STEPS = [];
-/**
-* Creates a rebinder instance for capturing and remapping a command's keys.
-* While it records it holds the whole keyboard, so no command runs on the
-* keys being pressed. 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) => {
-*     if (conflicts.length) console.warn("Conflict with", conflicts[0].id);
-*   },
-* });
-* rebinder.start();
-* ```
-*/
-function createRebinder(registry, id, options = {}) {
-	const sequence = options.mode === "sequence";
-	const listeners = /* @__PURE__ */ new Set();
-	let state = {
-		recording: false,
-		binding: null,
-		steps: NO_STEPS,
-		conflicts: []
-	};
-	let release = null;
-	let idle = null;
-	const set = (next) => {
-		state = next;
-		for (const listener of listeners) listener();
-	};
-	/** Gives the keyboard back. */
-	const end = () => {
-		release?.();
-		release = null;
-		if (idle !== null) clearTimeout(idle);
-		idle = null;
-	};
-	const record = (binding) => {
-		end();
-		const conflicts = registry.conflicts(binding, {
-			ignore: id,
-			scope: registry.get(id)?.scope
-		});
-		const blocked = options.rejectConflicts === true && conflicts.length > 0;
-		if (options.apply !== false && !blocked) {
-			if (options.add) registry.keymap.add(id, binding);
-			else registry.keymap.set(id, binding);
-		}
-		set({
-			recording: false,
-			binding,
-			steps: NO_STEPS,
-			conflicts
-		});
-		options.onRecord?.(binding, conflicts);
-	};
-	const cancel = () => {
-		end();
-		set({
-			...state,
-			recording: false,
-			steps: NO_STEPS
-		});
-		options.onCancel?.();
-	};
-	const clear = () => {
-		end();
-		if (options.apply !== false) registry.keymap.set(id, null);
-		set({
-			recording: false,
-			binding: null,
-			steps: NO_STEPS,
-			conflicts: []
-		});
-		options.onClear?.();
-	};
-	const commit = () => {
-		const [first, ...rest] = state.steps;
-		if (first === void 0) return;
-		record(rest.length === 0 ? first : { sequence: state.steps });
-	};
-	/** Sets the steps typed so far, and restarts the wait for the next one. */
-	const step = (steps) => {
-		if (idle !== null) clearTimeout(idle);
-		const wait = options.idleTimeout ?? 0;
-		idle = wait > 0 && steps.length > 0 ? setTimeout(commit, wait) : null;
-		set({
-			...state,
-			steps
-		});
-	};
-	const stop = () => {
-		if (!state.recording) return;
-		end();
-		set({
-			...state,
-			recording: false,
-			steps: NO_STEPS
-		});
-	};
-	const onKey = (event, chord) => {
-		if (options.ignoreInputs !== false && event.key !== "Escape" && isTyping(event)) return;
-		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 ? clear() : step(state.steps.slice(0, -1));
-		if (sequence && bare && event.key === "Enter") return commit();
-		if (chord === null) return;
-		if (sequence) step([...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: []
-			});
-		},
-		stop,
-		cancel: () => {
-			if (state.recording) cancel();
-		},
-		commit: () => {
-			if (state.recording && sequence) commit();
-		},
-		get state() {
-			return state;
-		},
-		subscribe: (listener) => {
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		destroy: () => {
-			stop();
-			listeners.clear();
-		}
-	};
-}
-/**
-* Whether commands in two scopes are live together whenever either is, so
-* their bindings can collide. A global or `"*"` command is live alongside
-* every scope; two different named scopes are separate surfaces, told apart
-* by which was opened last.
-*/
-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: a barrier claims the keyboard, not the command.
-	*/
-	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. The surface opened last sits highest, and wins a shared key.
-	*/
-	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 bindings that cannot work as written. */
-/**
-* Warns about every command: bad syntax, unknown overrides, collisions. The
-* registry calls this behind a `NODE_ENV` check, so a production build drops
-* this whole module.
-*/
-function auditRegistry(source) {
-	for (const id of source.ids) warnAboutBindings(source, id);
-	warnAboutUnknownOverrides(source);
-	warnAboutConflicts(source);
-}
-function warnAboutConflicts(source) {
-	const { platform, display } = source;
-	const seen = /* @__PURE__ */ new Map();
-	const collisions = [];
-	const prefixes = [];
-	const visited = [];
-	for (const id of source.ids) {
-		const scope = source.scope(id);
-		for (const binding of source.bindings(id)) {
-			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];
-				prefixes.push(`${formatBinding(short.binding, display)} ("${short.id}") is a prefix of ${formatBinding(long.binding, display)} ("${long.id}")`);
-			}
-			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;
-			}
-			collisions.push(`${formatBinding(binding, display)} — "${id}" shadows "${owner}"`);
-		}
-	}
-	if (collisions.length > 0) console.warn(`[@inklu/keys] ${collisions.length} shadowed binding(s) — same chord, same scope, so the later command takes the key whenever both have a handler:\n  ${collisions.join("\n  ")}`);
-	if (prefixes.length > 0) console.warn(`[@inklu/keys] ${prefixes.length} prefix collision(s) — the shorter binding fires on the way to the longer one:\n  ${prefixes.join("\n  ")}`);
-}
-function warnAboutBindings(source, id) {
-	for (const binding of source.declared(id)) {
-		const { valid, errors, warnings } = validateBinding(binding);
-		if (!valid) console.warn(`[@inklu/keys] "${id}" has an unrecognized binding ${describeBinding(binding)}, so it never fires. ${errors.join("; ")}.`);
-		else if (warnings.length > 0) console.warn(`[@inklu/keys] "${id}" binds ${describeBinding(binding)}. ${warnings.join(" ")}`);
-	}
-}
-/** Catches ids in `options.bindings` that TypeScript could not, as in plain JS. */
-function warnAboutUnknownOverrides(source) {
-	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) console.warn(`[@inklu/keys] bindings override ${unknown.map((id) => `"${id}"`).join(", ")}, which ${unknown.length === 1 ? "is not a registered command" : "are not registered commands"}.`);
-}
-function describeBinding(binding) {
-	return isSequence(binding) ? `"${binding.sequence.join(" ")}"` : `"${binding}"`;
-}
-//#endregion
-//#region src/keymap.ts
-/** Keymap managing default bindings and user overrides. */
-const DEFAULT_STORAGE_KEY = "inklu.keys";
-const KEYMAP_VERSION = 1;
-/** Type guard narrowing a JSON value to a plain object (excludes arrays and `null`). */
-function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
-* Same keys on every platform. The keymap is user data that may travel
-* between machines, so `Mod+S` and `Control+S` stay distinct here even on
-* Windows, where they happen to coincide.
-*/
-function portableSignature(binding) {
-	return `${bindingSignature(binding, "mac")} ${bindingSignature(binding, "windows")}`;
-}
-var Keymap = class {
-	#defaults = /* @__PURE__ */ new Map();
-	#overrides = /* @__PURE__ */ new Map();
-	#listeners = /* @__PURE__ */ new Set();
-	#persistence;
-	#loaded = false;
-	constructor(persistence) {
-		this.#persistence = persistence;
-	}
-	/** 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);
-	}
-	get(id) {
-		const defaults = this.#defaults.get(id) ?? [];
-		const override = this.#overrides.get(id);
-		if (!override) return defaults;
-		if (override.kind === "replace") return override.bindings;
-		return [...defaults, ...without(override.bindings, defaults)];
-	}
-	/** Replaces a command's bindings. Passing `null` unbinds it. */
-	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, {
-			kind: "replace",
-			bindings
-		});
-		this.#changed();
-	}
-	/** Adds an additional binding to a command. */
-	add(id, input) {
-		this.load();
-		const added = without(toBindings(input), this.get(id));
-		if (added.length === 0) return;
-		const override = this.#overrides.get(id);
-		this.#overrides.set(id, {
-			kind: override?.kind ?? "add",
-			bindings: [...override?.bindings ?? [], ...added]
-		});
-		this.#changed();
-	}
-	/** Resets user overrides to defaults for one command or all commands. */
-	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();
-	}
-	/** Exports user overrides as a serialized keymap object. */
-	export() {
-		return {
-			version: KEYMAP_VERSION,
-			overrides: Object.fromEntries(Array.from(this.#overrides, ([id, override]) => [id, serializeOverride(override)]))
-		};
-	}
-	/** Imports serialized user overrides and saves to storage. */
-	import(data) {
-		if (!this.#read(data)) return;
-		this.#loaded = true;
-		this.#changed();
-	}
-	/**
-	* Loads persisted overrides from storage, once; returns whether that
-	* changed anything (subscribers have then been told). The registry calls
-	* this on its first mount. `set`, `add` and `reset` call it too, so an
-	* edit made before mount lands on top of the stored overrides instead of
-	* writing over them.
-	*/
-	load() {
-		return !this.#loaded && this.#sync();
-	}
-	/** Reads the stored overrides, telling subscribers if they differ from the ones in memory. */
-	#sync() {
-		this.#loaded = true;
-		const storage = this.#storage();
-		if (!storage) return false;
-		const before = JSON.stringify(this.export());
-		try {
-			const raw = storage.getItem(this.#storageKey());
-			if (raw) this.#read(JSON.parse(raw));
-			else this.#overrides.clear();
-		} catch {
-			return false;
-		}
-		if (JSON.stringify(this.export()) === before) return false;
-		this.#notify();
-		return true;
-	}
-	/**
-	* Follows edits other tabs make to the stored overrides, so rebinding a
-	* key in one tab reaches the rest instead of being overwritten by the next
-	* stale tab to save. Returns a function that stops watching.
-	*/
-	watch() {
-		if (!this.#persistence || typeof window === "undefined") return () => {};
-		const onStorage = (event) => {
-			if (event.key !== null && event.key !== this.#storageKey()) return;
-			this.#sync();
-		};
-		window.addEventListener("storage", onStorage);
-		return () => window.removeEventListener("storage", onStorage);
-	}
-	/** Subscribes to keymap changes. Returns an unsubscribe function. */
-	subscribe(listener) {
-		this.#listeners.add(listener);
-		return () => {
-			this.#listeners.delete(listener);
-		};
-	}
-	/** Replaces the overrides with stored ones. `false` for data this release cannot read. */
-	#read(data) {
-		const entries = storedOverrides(data);
-		if (!entries) return false;
-		this.#overrides.clear();
-		for (const [id, value] of Object.entries(entries)) {
-			const override = deserializeOverride(value);
-			if (override) this.#overrides.set(id, override);
-		}
-		return true;
-	}
-	#changed() {
-		this.#persist();
-		this.#notify();
-	}
-	#notify() {
-		for (const listener of this.#listeners) listener();
-	}
-	#persist() {
-		const storage = this.#storage();
-		if (!storage) return;
-		try {
-			if (this.#overrides.size === 0) storage.removeItem(this.#storageKey());
-			else storage.setItem(this.#storageKey(), JSON.stringify(this.export()));
-		} catch {}
-	}
-	#storageKey() {
-		return this.#persistence?.key ?? DEFAULT_STORAGE_KEY;
-	}
-	#storage() {
-		try {
-			return this.#persistence?.storage() ?? null;
-		} catch {
-			return null;
-		}
-	}
-};
-/** `bindings` minus any already in `existing` or repeated, compared across platforms. */
-function without(bindings, existing) {
-	const known = new Set(existing.map(portableSignature));
-	return bindings.filter((binding) => {
-		const signature = portableSignature(binding);
-		if (known.has(signature)) return false;
-		known.add(signature);
-		return true;
-	});
-}
-/** 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) => {
-		const other = b[index];
-		return other !== void 0 && portableSignature(binding) === portableSignature(other);
-	});
-}
-/** The overrides in stored data, or `null` if this release cannot read it. */
-function storedOverrides(data) {
-	if (!isJsonObject(data)) return null;
-	if (typeof data.version !== "number") return data;
-	if (data.version !== KEYMAP_VERSION) return null;
-	const overrides = data.overrides;
-	return overrides !== void 0 && isJsonObject(overrides) ? overrides : null;
-}
-function serializeOverride(override) {
-	const bindings = override.bindings.map(serializeBinding);
-	return override.kind === "replace" ? bindings : { add: bindings };
-}
-function deserializeOverride(value) {
-	if (Array.isArray(value)) {
-		const bindings = deserializeBindings(value);
-		return bindings && {
-			kind: "replace",
-			bindings
-		};
-	}
-	if (isJsonObject(value) && Array.isArray(value.add)) {
-		const bindings = deserializeBindings(value.add);
-		return bindings && bindings.length > 0 ? {
-			kind: "add",
-			bindings
-		} : null;
-	}
-	return null;
-}
-/**
-* `[]` is how an unbound command is stored. A non-empty list with nothing
-* usable in it is damage — hand edits, another version's format — and
-* reading it as "unbound" would silently strip the command of its default
-* shortcut, so it reads as `null` instead.
-*/
-function deserializeBindings(values) {
-	const bindings = values.map(deserializeBinding).filter((binding) => binding !== null);
-	return bindings.length === 0 && values.length > 0 ? null : bindings;
-}
-//#endregion
-//#region src/registry.ts
-/** Command registry: what an app can do, which keys do it, and where each is live. */
-const SSR_PLATFORM = "windows";
-var CommandRegistry = class {
-	#definitions;
-	/** Handlers attached per command, the most recent last. */
-	#handlers = /* @__PURE__ */ new Map();
-	#keymap;
-	#scopes = new ScopeStack();
-	#keys;
-	#options;
-	#listeners = /* @__PURE__ */ new Set();
-	#snapshot = null;
-	#serverSnapshot = null;
-	#pending = null;
-	/** Stops following other tabs' keymap edits; set while mounted. */
-	#unwatch = null;
-	#mounts = 0;
-	#hydrated = false;
-	#singleKeys;
-	constructor(definitions, options = {}) {
-		this.#options = options;
-		this.#singleKeys = options.singleKeyShortcuts !== false;
-		this.#keymap = new Keymap(options.persist);
-		this.#definitions = /* @__PURE__ */ new Map();
-		for (const id in definitions) {
-			const definition = definitions[id];
-			this.#definitions.set(id, definition);
-			this.#keymap.setDefault(id, this.#defaultKeys(id, definition));
-		}
-		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
-			})
-		}, options.target);
-		this.#keymap.subscribe(() => this.#bindingsChanged());
-		this.#scopes.subscribe(() => this.#reachabilityChanged());
-		if (process.env.NODE_ENV !== "production") auditRegistry({
-			ids: [...this.#definitions.keys()],
-			scope: (id) => this.#definitions.get(id)?.scope,
-			bindings: (id) => this.#bindings(id),
-			declared: (id) => this.#keymap.get(id),
-			overrides: options.bindings,
-			platform: this.#platform(),
-			display: this.#displayOptions()
-		});
-	}
-	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 options = {
-			platform,
-			...this.#options.display
-		};
-		const singleKeys = this.#options.singleKeyShortcuts !== false;
-		this.#serverSnapshot = Array.from(this.#definitions, ([id, definition]) => {
-			const bindings = toBindings(this.#defaultKeys(id, definition)).filter((binding) => singleKeys || !isSingleKeyBinding(binding));
-			const global = definition.scope === void 0 || definition.scope === "*";
-			return describeCommand(id, definition, bindings, platform, options, {
-				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;
-	}
-	canRun(id) {
-		return this.whyNotRun(id) === null;
-	}
-	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.#reachabilityChanged();
-		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.#reachabilityChanged();
-		};
-	}
-	pushScope(name, options) {
-		return this.#scopes.push(name, options);
-	}
-	capture(onKey) {
-		const release = this.#keys.capture(onKey);
-		this.#reachabilityChanged();
-		let released = false;
-		return () => {
-			if (released) return;
-			released = true;
-			release();
-			this.#reachabilityChanged();
-		};
-	}
-	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;
-				const display = formatBinding(existing, this.#displayOptions());
-				conflicts.push({
-					id,
-					binding: existing,
-					kind,
-					display,
-					scope
-				});
-			}
-		}
-		return conflicts;
-	}
-	pending() {
-		const from = this.#keys.progress();
-		if (this.#pending?.from !== from) {
-			const options = this.#displayOptions();
-			this.#pending = {
-				from,
-				list: from.map(({ id, binding, matched }) => ({
-					id,
-					binding,
-					matched,
-					total: binding.sequence.length,
-					remaining: binding.sequence.slice(matched).map((step) => formatBinding(step, options))
-				}))
-			};
-		}
-		return this.#pending.list;
-	}
-	subscribePending(listener) {
-		return this.#keys.watch(listener);
-	}
-	get singleKeyShortcuts() {
-		return this.#singleKeys;
-	}
-	setSingleKeyShortcuts(enabled) {
-		if (this.#singleKeys === enabled) return;
-		this.#singleKeys = enabled;
-		this.#bindingsChanged();
-	}
-	mount() {
-		this.#mounts++;
-		if (this.#mounts === 1) {
-			this.#hydrated = true;
-			this.#unwatch = this.#keymap.watch();
-			this.#keys.attach();
-			if (!this.#keymap.load()) this.#bindingsChanged();
-		}
-		let released = false;
-		return () => {
-			if (released) return;
-			released = true;
-			if (this.#mounts === 0) return;
-			this.#mounts--;
-			if (this.#mounts === 0) this.#unmount();
-		};
-	}
-	subscribe(listener) {
-		this.#listeners.add(listener);
-		return () => {
-			this.#listeners.delete(listener);
-		};
-	}
-	destroy() {
-		this.#mounts = 0;
-		this.#unwatch?.();
-		this.#unwatch = null;
-		this.#keys.destroy();
-		this.#definitions.clear();
-		this.#handlers.clear();
-		this.#serverSnapshot = null;
-		this.#invalidate();
-		this.#listeners.clear();
-		this.#scopes.clear();
-	}
-	#unmount() {
-		this.#keys.detach();
-		this.#unwatch?.();
-		this.#unwatch = null;
-	}
-	/** 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. Everything that binds, displays or compares keys reads
-	* this, so a suppressed shortcut is not advertised either.
-	*/
-	#bindings(id) {
-		const bindings = this.#keymap.get(id);
-		if (this.#singleKeys) return bindings;
-		return bindings.filter((binding) => !isSingleKeyBinding(binding));
-	}
-	/**
-	* A command's default keys: the app's `options.bindings` entry if it has
-	* one, else the definition's own. `hasOwn`, not `??`: a `null` entry
-	* deliberately ships the command unbound, and `??` would read that as
-	* "absent" and restore the very default the app asked to drop.
-	*/
-	#defaultKeys(id, definition) {
-		const overrides = this.#options.bindings;
-		return overrides && Object.hasOwn(overrides, id) ? overrides[id] : definition.keys;
-	}
-	#execute(id, context) {
-		const run = this.#handler(id);
-		if (!run) return;
-		const full = {
-			id,
-			...context,
-			commands: this
-		};
-		if (this.#options.onRun) try {
-			this.#options.onRun(full);
-		} catch (error) {
-			this.#reportError(toError(error), full);
-		}
-		try {
-			const result = run(full);
-			if (result instanceof Promise) result.catch((cause) => this.#reportError(toError(cause), full));
-		} catch (error) {
-			this.#reportError(toError(error), full);
-		}
-	}
-	#reportError(error, context) {
-		if (this.#options.onError) {
-			this.#options.onError(error, context);
-			return;
-		}
-		console.error(`[@inklu/keys] command "${context.id}" failed`, error);
-	}
-	#bindingsChanged() {
-		this.#keys.refresh();
-		this.#invalidate();
-	}
-	#reachabilityChanged() {
-		this.#keys.prune();
-		this.#invalidate();
-	}
-	#platform() {
-		return this.#options.platform ?? (this.#hydrated ? detectPlatform() : SSR_PLATFORM);
-	}
-	#displayOptions() {
-		return {
-			platform: this.#platform(),
-			...this.#options.display
-		};
-	}
-	#snapshots() {
-		if (this.#snapshot) return this.#snapshot;
-		const platform = this.#platform();
-		const options = this.#displayOptions();
-		const list = [];
-		const index = /* @__PURE__ */ new Map();
-		for (const [id, definition] of this.#definitions) {
-			const command = describeCommand(id, definition, this.#bindings(id), platform, options, {
-				reachable: this.#reachable(id),
-				overridden: this.#keymap.isOverridden(id)
-			});
-			list.push(command);
-			index.set(id, command);
-		}
-		this.#snapshot = {
-			list,
-			index
-		};
-		return this.#snapshot;
-	}
-	#invalidate() {
-		this.#snapshot = null;
-		for (const listener of this.#listeners) listener();
-	}
-};
-function describeCommand(id, definition, source, platform, options, state) {
-	const bindings = [...source];
-	return {
-		id,
-		title: definition.title,
-		description: definition.description,
-		group: definition.group,
-		keywords: definition.keywords ?? [],
-		hidden: definition.hidden === true,
-		scope: definition.scope,
-		bindings,
-		display: bindings.map((binding) => formatBinding(binding, options)),
-		tokens: bindings.map((binding) => bindingTokens(binding, options)),
-		aria: bindings.map((binding) => ariaKeyShortcuts(binding, platform)).filter((value) => value.length > 0).join(" "),
-		spoken: bindings.map((binding) => spokenBinding(binding, platform)).join(" or "),
-		...state
-	};
-}
-/** Normalizes an arbitrary thrown value into a real `Error` at the catch boundary. */
-function toError(cause) {
-	return cause instanceof Error ? cause : new Error(String(cause));
-}
-/**
-* 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
-//#region src/search.ts
-/**
-* Filters commands for a search query, as a command palette does, leaving
-* out `hidden` ones. Every word of the query must appear somewhere in the
-* command — title, description, group, keywords, id or displayed shortcut —
-* in any order. Title matches come first: titles starting with the query,
-* then titles containing every word, then the rest; each tier keeps the
-* list's own order. An empty query returns every visible command.
-*
-* @example
-* ```ts
-* const results = matchCommands(commands.list(), "go inbox");
-* ```
-*/
-function matchCommands(commands, query) {
-	const visible = commands.filter((command) => !command.hidden);
-	const needle = query.trim().toLowerCase();
-	if (!needle) return visible;
-	const terms = needle.split(/\s+/);
-	const ranked = [];
-	for (const command of visible) {
-		const title = command.title.toLowerCase();
-		const text = [
-			title,
-			command.description,
-			command.group,
-			command.id,
-			...command.keywords,
-			...command.display
-		].join("\n").toLowerCase();
-		if (!terms.every((term) => text.includes(term))) continue;
-		const rank = title.startsWith(needle) ? 0 : terms.every((term) => title.includes(term)) ? 1 : 2;
-		ranked.push({
-			command,
-			rank
-		});
-	}
-	return ranked.sort((a, b) => a.rank - b.rank).map(({ command }) => command);
-}
-//#endregion
-export { bindingTokens as a, isSingleKeyBinding as c, isModifierKey as d, keyName as f, ariaKeyShortcuts as i, seq as l, createCommands as n, formatBinding as o, createRebinder as r, spokenBinding as s, matchCommands as t, validateBinding as u };