@opentui/keymap 0.2.1 → 0.2.3

package/src/addons/index.js

@@ -0,0 +1,1130 @@
+// @bun
+// src/addons/universal/default-parser.ts
+var namedSingleStrokeKeys = new Set([
+  "up",
+  "down",
+  "left",
+  "right",
+  "clear",
+  "escape",
+  "return",
+  "linefeed",
+  "enter",
+  "tab",
+  "backspace",
+  "delete",
+  "insert",
+  "home",
+  "end",
+  "pageup",
+  "pagedown",
+  "space",
+  "lt",
+  "gt",
+  "plus",
+  "minus",
+  "equal",
+  "comma",
+  "period",
+  "slash",
+  "backslash",
+  "semicolon",
+  "quote",
+  "backquote",
+  "leftbracket",
+  "rightbracket",
+  "capslock",
+  "numlock",
+  "scrolllock",
+  "printscreen",
+  "pause",
+  "menu",
+  "apps",
+  "kp0",
+  "kp1",
+  "kp2",
+  "kp3",
+  "kp4",
+  "kp5",
+  "kp6",
+  "kp7",
+  "kp8",
+  "kp9",
+  "kpdecimal",
+  "kpdivide",
+  "kpmultiply",
+  "kpminus",
+  "kpplus",
+  "kpenter",
+  "kpequal",
+  "kpseparator",
+  "kpleft",
+  "kpright",
+  "kpup",
+  "kpdown",
+  "kppageup",
+  "kppagedown",
+  "kphome",
+  "kpend",
+  "kpinsert",
+  "kpdelete",
+  "mediaplay",
+  "mediapause",
+  "mediaplaypause",
+  "mediareverse",
+  "mediastop",
+  "mediafastforward",
+  "mediarewind",
+  "medianext",
+  "mediaprev",
+  "mediarecord",
+  "volumedown",
+  "volumeup",
+  "mute",
+  "leftshift",
+  "leftctrl",
+  "leftalt",
+  "leftsuper",
+  "lefthyper",
+  "leftmeta",
+  "rightshift",
+  "rightctrl",
+  "rightalt",
+  "rightsuper",
+  "righthyper",
+  "rightmeta",
+  "iso_level3_shift",
+  "iso_level5_shift",
+  "option",
+  "alt",
+  "meta",
+  "super",
+  "hyper",
+  "control",
+  "ctrl",
+  "shift"
+]);
+var modifierKeyNames = new Set(["ctrl", "control", "shift", "meta", "alt", "option", "super", "hyper"]);
+var namedSingleStrokeKeyPrefixes = createPrefixBuckets(namedSingleStrokeKeys);
+var modifierKeyPrefixes = createPrefixBuckets(modifierKeyNames);
+function createPrefixBuckets(values) {
+  const buckets = new Map;
+  for (const value of values) {
+    const first = value.charCodeAt(0);
+    if (Number.isNaN(first)) {
+      continue;
+    }
+    let bucket = buckets.get(first);
+    if (!bucket) {
+      bucket = [];
+      buckets.set(first, bucket);
+    }
+    bucket.push(value);
+  }
+  for (const bucket of buckets.values()) {
+    bucket.sort((left, right) => right.length - left.length);
+  }
+  return buckets;
+}
+function toLowerAsciiCode(code) {
+  return code >= 65 && code <= 90 ? code + 32 : code;
+}
+function isDigitCode(code) {
+  return code >= 48 && code <= 57;
+}
+function startsWithAsciiInsensitive(input, prefix, index) {
+  if (input.startsWith(prefix, index)) {
+    return true;
+  }
+  if (index + prefix.length > input.length) {
+    return false;
+  }
+  for (let offset = 0;offset < prefix.length; offset += 1) {
+    if (toLowerAsciiCode(input.charCodeAt(index + offset)) !== prefix.charCodeAt(offset)) {
+      return false;
+    }
+  }
+  return true;
+}
+function findBucketedPrefixMatch(buckets, input, index) {
+  const first = input.charCodeAt(index);
+  if (Number.isNaN(first)) {
+    return;
+  }
+  const candidates = buckets.get(toLowerAsciiCode(first));
+  if (!candidates) {
+    return;
+  }
+  for (const candidate of candidates) {
+    if (startsWithAsciiInsensitive(input, candidate, index)) {
+      return candidate;
+    }
+  }
+  return;
+}
+function parseObjectKeyInput(ctx, key, display, match, tokenName) {
+  return ctx.parseObjectKey(key, {
+    display,
+    match,
+    tokenName
+  });
+}
+function parseStringKeyPart(input, ctx) {
+  if (input === " ") {
+    return ctx.parseObjectKey({ name: "space" }, { display: "space" });
+  }
+  if (input === "+") {
+    return ctx.parseObjectKey({ name: "+" }, { display: "+" });
+  }
+  const parts = input.split("+");
+  let name = "";
+  let displayName = "";
+  let ctrl = false;
+  let shift = false;
+  let meta = false;
+  let superKey = false;
+  let hyper = false;
+  for (const rawPart of parts) {
+    const part = rawPart.trim();
+    if (!part) {
+      continue;
+    }
+    const lowered = part.toLowerCase();
+    if (lowered === "ctrl" || lowered === "control") {
+      ctrl = true;
+      continue;
+    }
+    if (lowered === "shift") {
+      shift = true;
+      continue;
+    }
+    if (lowered === "meta" || lowered === "alt" || lowered === "option") {
+      meta = true;
+      continue;
+    }
+    if (lowered === "super") {
+      superKey = true;
+      continue;
+    }
+    if (lowered === "hyper") {
+      hyper = true;
+      continue;
+    }
+    if (name) {
+      throw new Error(`Invalid key "${input}": multiple key names are not supported`);
+    }
+    name = part;
+    displayName = lowered;
+  }
+  if (!name) {
+    throw new Error(`Invalid key "${input}": missing key name`);
+  }
+  const displayParts = [];
+  if (ctrl)
+    displayParts.push("ctrl");
+  if (shift)
+    displayParts.push("shift");
+  if (meta)
+    displayParts.push("meta");
+  if (superKey)
+    displayParts.push("super");
+  if (hyper)
+    displayParts.push("hyper");
+  displayParts.push(displayName);
+  return ctx.parseObjectKey({
+    name,
+    ctrl,
+    shift,
+    meta,
+    super: superKey,
+    hyper: hyper || undefined
+  }, {
+    display: displayParts.join("+")
+  });
+}
+function parseNamedKeyPart(name, ctx) {
+  const normalized = name.trim().toLowerCase();
+  return ctx.parseObjectKey({ name: normalized }, { display: normalized });
+}
+function findNamedSingleStrokeKey(input, index) {
+  const namedKey = findBucketedPrefixMatch(namedSingleStrokeKeyPrefixes, input, index);
+  if (namedKey) {
+    return namedKey;
+  }
+  if (toLowerAsciiCode(input.charCodeAt(index)) !== 102 || !isDigitCode(input.charCodeAt(index + 1))) {
+    return;
+  }
+  const end = isDigitCode(input.charCodeAt(index + 2)) ? index + 3 : index + 2;
+  return input.slice(index, end).toLowerCase();
+}
+function findModifierKey(input, index) {
+  return findBucketedPrefixMatch(modifierKeyPrefixes, input, index);
+}
+function parseModifiedKeyPart(input, index, ctx) {
+  let cursor = index;
+  let ctrl = false;
+  let shift = false;
+  let meta = false;
+  let superKey = false;
+  let hyper = false;
+  while (cursor < input.length) {
+    const modifier = findModifierKey(input, cursor);
+    if (!modifier) {
+      break;
+    }
+    const plusIndex = cursor + modifier.length;
+    if (input[plusIndex] !== "+") {
+      break;
+    }
+    if (modifier === "ctrl" || modifier === "control") {
+      ctrl = true;
+    } else if (modifier === "shift") {
+      shift = true;
+    } else if (modifier === "meta" || modifier === "alt" || modifier === "option") {
+      meta = true;
+    } else if (modifier === "super") {
+      superKey = true;
+    } else if (modifier === "hyper") {
+      hyper = true;
+    }
+    cursor = plusIndex + 1;
+  }
+  if (cursor === index) {
+    return;
+  }
+  const char = input[cursor];
+  if (char === undefined) {
+    throw new Error(`Invalid key "${input.slice(index)}": missing key name`);
+  }
+  const name = findNamedSingleStrokeKey(input, cursor) ?? char;
+  const displayName = name === " " ? "space" : name === "+" ? "+" : name.toLowerCase();
+  const displayParts = [];
+  if (ctrl)
+    displayParts.push("ctrl");
+  if (shift)
+    displayParts.push("shift");
+  if (meta)
+    displayParts.push("meta");
+  if (superKey)
+    displayParts.push("super");
+  if (hyper)
+    displayParts.push("hyper");
+  displayParts.push(displayName);
+  return {
+    part: ctx.parseObjectKey({
+      name: name === " " ? "space" : name,
+      ctrl,
+      shift,
+      meta,
+      super: superKey,
+      hyper: hyper || undefined
+    }, {
+      display: displayParts.join("+")
+    }),
+    nextIndex: cursor + name.length
+  };
+}
+var defaultBindingParser = (ctx) => {
+  const { input, index, tokens, normalizeTokenName } = ctx;
+  if (index === 0 && input.includes("+") && /\s/.test(input)) {
+    return {
+      parts: [parseStringKeyPart(input, ctx)],
+      nextIndex: input.length
+    };
+  }
+  const char = input[index];
+  if (char === undefined) {
+    return;
+  }
+  if (char === "<") {
+    const end = input.indexOf(">", index);
+    if (end === -1) {
+      return {
+        parts: [parseStringKeyPart(char, ctx)],
+        nextIndex: index + 1
+      };
+    }
+    const tokenName = normalizeTokenName(input.slice(index + 1, end));
+    const token = tokens.get(tokenName);
+    if (!token) {
+      return {
+        parts: [],
+        nextIndex: end + 1,
+        unknownTokens: [tokenName]
+      };
+    }
+    return {
+      parts: [parseObjectKeyInput(ctx, token.stroke, `<${tokenName}>`, token.match, tokenName)],
+      nextIndex: end + 1,
+      usedTokens: [tokenName]
+    };
+  }
+  if (char === "{") {
+    const end = input.indexOf("}", index);
+    if (end === -1) {
+      return {
+        parts: [parseStringKeyPart(char, ctx)],
+        nextIndex: index + 1
+      };
+    }
+    const patternName = normalizeTokenName(input.slice(index + 1, end));
+    const pattern = ctx.patterns.get(patternName);
+    if (!pattern) {
+      return {
+        parts: [],
+        nextIndex: end + 1,
+        unknownTokens: [patternName]
+      };
+    }
+    const part = ctx.parseObjectKey({ name: patternName, ctrl: false, shift: false, meta: false, super: false }, { display: pattern.display ?? `{${patternName}}`, match: pattern.match });
+    return {
+      parts: [{ ...part, patternName: pattern.name, payloadKey: pattern.payloadKey }],
+      nextIndex: end + 1,
+      usedTokens: [patternName]
+    };
+  }
+  const modified = parseModifiedKeyPart(input, index, ctx);
+  if (modified) {
+    return {
+      parts: [modified.part],
+      nextIndex: modified.nextIndex
+    };
+  }
+  const namedKey = findNamedSingleStrokeKey(input, index);
+  if (namedKey) {
+    return {
+      parts: [parseNamedKeyPart(namedKey, ctx)],
+      nextIndex: index + namedKey.length
+    };
+  }
+  return {
+    parts: [parseStringKeyPart(char, ctx)],
+    nextIndex: index + 1
+  };
+};
+var defaultEventMatchResolver = (event, ctx) => {
+  return [
+    ctx.resolveKey({
+      name: event.name,
+      ctrl: event.ctrl,
+      shift: event.shift,
+      meta: event.meta,
+      super: event.super ?? false,
+      hyper: event.hyper || undefined
+    })
+  ];
+};
+function registerDefaultBindingParser(keymap) {
+  return keymap.appendBindingParser((ctx) => defaultBindingParser(ctx));
+}
+function registerDefaultEventMatchResolver(keymap) {
+  return keymap.appendEventMatchResolver((event, ctx) => defaultEventMatchResolver(event, ctx));
+}
+function registerDefaultKeys(keymap) {
+  const offParser = registerDefaultBindingParser(keymap);
+  const offResolver = registerDefaultEventMatchResolver(keymap);
+  return () => {
+    offResolver();
+    offParser();
+  };
+}
+// src/addons/universal/binding-overrides.ts
+var BINDING_OVERRIDES_RESOURCE = Symbol("keymap:binding-overrides");
+function normalizeBindingOverrides(value) {
+  if (!Array.isArray(value)) {
+    throw new Error('Keymap layer field "bindingOverrides" must be an array of binding objects');
+  }
+  return value;
+}
+function getBindingOverrides(layer) {
+  const overrides = layer.bindingOverrides;
+  if (!overrides || !Array.isArray(overrides)) {
+    return;
+  }
+  return normalizeBindingOverrides(overrides);
+}
+function registerBindingOverrides(keymap) {
+  return keymap.acquireResource(BINDING_OVERRIDES_RESOURCE, () => {
+    const offLayerField = keymap.registerLayerFields({
+      bindingOverrides(value) {
+        normalizeBindingOverrides(value);
+      }
+    });
+    const offTransformer = keymap.appendLayerBindingsTransformer((bindings, ctx) => {
+      const overrides = getBindingOverrides(ctx.layer);
+      if (!overrides) {
+        return;
+      }
+      const validation = ctx.validateBindings(overrides);
+      if (!validation.ok) {
+        throw new Error(validation.reason);
+      }
+      const overrideCommands = new Set(overrides.flatMap((binding) => typeof binding.cmd === "string" ? [binding.cmd.trim()] : []));
+      return [
+        ...overrides,
+        ...bindings.filter((binding) => {
+          return typeof binding.cmd !== "string" || !overrideCommands.has(binding.cmd.trim());
+        })
+      ];
+    });
+    return () => {
+      offTransformer();
+      offLayerField();
+    };
+  });
+}
+// src/addons/universal/aliases.ts
+var ALIASES_FIELD_RESOURCE = Symbol("keymap:aliases-field");
+function normalizeAliases(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error('Keymap aliases field "aliases" must be an object of key-name mappings');
+  }
+  const aliases = {};
+  for (const [name, key] of Object.entries(value)) {
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+      throw new Error('Keymap aliases field "aliases" cannot contain empty alias names');
+    }
+    if (typeof key !== "string") {
+      throw new Error(`Keymap alias "${trimmedName}" must map to a string key name`);
+    }
+    const trimmedKey = key.trim();
+    if (!trimmedKey) {
+      throw new Error(`Keymap alias "${trimmedName}" cannot map to an empty key name`);
+    }
+    aliases[trimmedName.toLowerCase()] = trimmedKey.toLowerCase();
+  }
+  return aliases;
+}
+function getAliases(layer) {
+  const aliases = layer.aliases;
+  if (!aliases || typeof aliases !== "object" || Array.isArray(aliases)) {
+    return;
+  }
+  return normalizeAliases(aliases);
+}
+function registerAliasesField(keymap) {
+  return keymap.acquireResource(ALIASES_FIELD_RESOURCE, () => {
+    const offLayerField = keymap.registerLayerFields({
+      aliases(value, ctx) {
+        normalizeAliases(value);
+      }
+    });
+    const offBindingTransformer = keymap.appendBindingTransformer((binding, ctx) => {
+      const aliases = getAliases(ctx.layer);
+      if (!aliases) {
+        return;
+      }
+      if (binding.sequence.length !== 1) {
+        return;
+      }
+      const [part] = binding.sequence;
+      if (!part) {
+        return;
+      }
+      const aliasedName = aliases[part.stroke.name];
+      if (!aliasedName) {
+        return;
+      }
+      ctx.add({
+        ...binding,
+        sequence: [
+          ctx.parseKey({
+            ...part.stroke,
+            name: aliasedName
+          })
+        ]
+      });
+    });
+    return () => {
+      offBindingTransformer();
+      offLayerField();
+    };
+  });
+}
+// src/addons/universal/backspace-pops-pending-sequence.ts
+function registerBackspacePopsPendingSequence(keymap, options) {
+  const shouldPreventDefault = options?.preventDefault ?? true;
+  return keymap.intercept("key", ({ event, consume }) => {
+    if (event.name !== "backspace") {
+      return;
+    }
+    if (!keymap.popPendingSequence()) {
+      return;
+    }
+    if (shouldPreventDefault) {
+      consume();
+    }
+  }, { priority: options?.priority ?? 0 });
+}
+// src/addons/universal/comma-bindings.ts
+var COMMA_BINDINGS_RESOURCE = Symbol("keymap:comma-bindings");
+var commaBindingExpander = ({ input, displays }) => {
+  if (!input.includes(",")) {
+    return;
+  }
+  const parts = input.split(",").map((part) => part.trim());
+  if (parts.some((part) => part.length === 0)) {
+    throw new Error(`Invalid key sequence "${input}": comma-separated bindings cannot contain empty entries`);
+  }
+  if (!displays) {
+    return parts.map((key) => ({ key }));
+  }
+  const displayParts = displays.length === 1 ? displays[0].split(",").map((part) => part.trim()) : displays;
+  if (displayParts.length !== parts.length || displayParts.some((part) => part.length === 0)) {
+    return parts.map((key) => ({ key }));
+  }
+  return parts.map((key, index) => ({
+    key,
+    displays: displayParts[index].trim().split(/\s+/).filter(Boolean)
+  }));
+};
+function registerCommaBindings(keymap) {
+  return keymap.acquireResource(COMMA_BINDINGS_RESOURCE, () => {
+    return keymap.appendBindingExpander(commaBindingExpander);
+  });
+}
+// src/addons/universal/dead-bindings.ts
+import { stringifyKeySequence, stringifyKeyStroke } from "@opentui/keymap";
+var DEAD_BINDING_WARNINGS_RESOURCE = Symbol("keymap:dead-binding-warnings");
+function isDeadMetadataOnlyBinding(binding) {
+  if (binding.command !== undefined) {
+    return false;
+  }
+  if (binding.event === "release") {
+    return true;
+  }
+  return !binding.hasContinuations && !binding.hasCommandAtSequence;
+}
+function warnDeadMetadataOnlyBinding(ctx, binding) {
+  const sequence = stringifyKeySequence(binding.parsedBinding.sequence, { preferDisplay: true });
+  const sourceKey = typeof binding.parsedBinding.key === "string" ? binding.parsedBinding.key : stringifyKeyStroke(binding.parsedBinding.key);
+  const warningKey = `dead-binding:${binding.sourceLayerOrder}:${binding.bindingIndex}:${sourceKey}`;
+  ctx.warnOnce(warningKey, "dead-binding", {
+    binding: binding.parsedBinding,
+    target: binding.sourceTarget
+  }, `[Keymap] Binding "${sequence}" has no command and no reachable continuations; it will never trigger`);
+}
+function registerDeadBindingWarnings(keymap) {
+  return keymap.acquireResource(DEAD_BINDING_WARNINGS_RESOURCE, () => {
+    return keymap.appendLayerAnalyzer((ctx) => {
+      for (const binding of ctx.bindings) {
+        if (!isDeadMetadataOnlyBinding(binding)) {
+          continue;
+        }
+        warnDeadMetadataOnlyBinding(ctx, binding);
+      }
+    });
+  });
+}
+// src/addons/universal/escape-clears-pending-sequence.ts
+function registerEscapeClearsPendingSequence(keymap, options) {
+  const shouldPreventDefault = options?.preventDefault ?? true;
+  return keymap.intercept("key", ({ event, consume }) => {
+    if (event.name !== "escape") {
+      return;
+    }
+    if (!keymap.hasPendingSequence()) {
+      return;
+    }
+    keymap.clearPendingSequence();
+    if (shouldPreventDefault) {
+      consume();
+    }
+  }, { priority: options?.priority ?? 0 });
+}
+// src/addons/universal/enabled.ts
+var ENABLED_FIELDS_RESOURCE = Symbol("keymap:enabled-fields");
+function isReactiveMatcher(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.get === "function" && typeof candidate.subscribe === "function";
+}
+function normalizeEnabledValue(fieldName, value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "function") {
+    return value;
+  }
+  if (isReactiveMatcher(value)) {
+    return value;
+  }
+  throw new Error(`Keymap enabled field "${fieldName}" must be a boolean, a function, or a reactive matcher`);
+}
+function registerEnabledFields(keymap) {
+  return keymap.acquireResource(ENABLED_FIELDS_RESOURCE, () => {
+    const offLayerFields = keymap.registerLayerFields({
+      enabled(value, ctx) {
+        const normalized = normalizeEnabledValue("enabled", value);
+        if (normalized === true) {
+          return;
+        }
+        if (normalized === false) {
+          ctx.activeWhen(() => false);
+          return;
+        }
+        ctx.activeWhen(normalized);
+      }
+    });
+    const offCommandFields = keymap.registerCommandFields({
+      enabled(value, ctx) {
+        const normalized = normalizeEnabledValue("enabled", value);
+        if (normalized === true) {
+          return;
+        }
+        if (normalized === false) {
+          ctx.activeWhen(() => false);
+          return;
+        }
+        ctx.activeWhen(normalized);
+      }
+    });
+    return () => {
+      offCommandFields();
+      offLayerFields();
+    };
+  });
+}
+// src/addons/universal/emacs-bindings.ts
+var EMACS_BINDINGS_RESOURCE = Symbol("keymap:emacs-bindings");
+function parseEmacsStroke(input, sequence, parseObjectKey) {
+  const parts = input.split("+");
+  let name = "";
+  let ctrl = false;
+  let shift = false;
+  let meta = false;
+  let superKey = false;
+  let hyper = false;
+  for (const rawPart of parts) {
+    const part = rawPart.trim();
+    if (!part) {
+      continue;
+    }
+    const lowered = part.toLowerCase();
+    if (lowered === "ctrl" || lowered === "control") {
+      ctrl = true;
+      continue;
+    }
+    if (lowered === "shift") {
+      shift = true;
+      continue;
+    }
+    if (lowered === "meta" || lowered === "alt" || lowered === "option") {
+      meta = true;
+      continue;
+    }
+    if (lowered === "super") {
+      superKey = true;
+      continue;
+    }
+    if (lowered === "hyper") {
+      hyper = true;
+      continue;
+    }
+    if (name) {
+      throw new Error(`Invalid emacs key sequence "${sequence}": stroke "${input}" contains multiple key names`);
+    }
+    name = part;
+  }
+  if (!name) {
+    throw new Error(`Invalid emacs key sequence "${sequence}": stroke "${input}" is missing a key name`);
+  }
+  return parseObjectKey({
+    name,
+    ctrl,
+    shift,
+    meta,
+    super: superKey,
+    hyper: hyper || undefined
+  });
+}
+function parseEmacsSequence(input, parseObjectKey) {
+  const strokes = input.trim().split(/\s+/).filter(Boolean);
+  if (strokes.length <= 1) {
+    return;
+  }
+  if (!strokes.some((stroke) => stroke.includes("+"))) {
+    return;
+  }
+  return strokes.map((stroke) => parseEmacsStroke(stroke, input, parseObjectKey));
+}
+function registerEmacsBindings(keymap) {
+  return keymap.acquireResource(EMACS_BINDINGS_RESOURCE, () => {
+    const parseEmacsBinding = ({ input, index, parseObjectKey }) => {
+      const parsed = parseEmacsSequence(input, parseObjectKey);
+      if (!parsed || index !== 0) {
+        return;
+      }
+      return {
+        parts: parsed,
+        nextIndex: input.length
+      };
+    };
+    return keymap.prependBindingParser(parseEmacsBinding);
+  });
+}
+// src/addons/universal/ex-commands.ts
+var EX_COMMANDS_RESOURCE = Symbol("keymap:ex-commands");
+function isExCommandPayload(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.raw === "string" && Array.isArray(candidate.args);
+}
+function getExCommandPayload(input, payload) {
+  if (isExCommandPayload(payload)) {
+    return payload;
+  }
+  return { raw: input, args: [], payload };
+}
+function normalizeExCommandName(name) {
+  const normalized = name.trim();
+  if (!normalized) {
+    throw new Error("Invalid keymap command name: name cannot be empty");
+  }
+  if (/\s/.test(normalized)) {
+    throw new Error(`Invalid keymap command name "${name}": command names cannot contain whitespace`);
+  }
+  if (normalized.startsWith(":")) {
+    return normalized;
+  }
+  return `:${normalized}`;
+}
+function normalizeExCommandAliases(value) {
+  if (!Array.isArray(value)) {
+    throw new Error('Keymap ex-command field "aliases" must be an array of command names');
+  }
+  const aliases = [];
+  for (const alias of value) {
+    if (typeof alias !== "string") {
+      throw new Error('Keymap ex-command field "aliases" must only contain command names');
+    }
+    aliases.push(alias);
+  }
+  return aliases;
+}
+function normalizeExCommandNargs(value) {
+  if (value === "0" || value === "1" || value === "?" || value === "*" || value === "+") {
+    return value;
+  }
+  throw new Error('Keymap ex-command field "nargs" must be "0", "1", "?", "*", or "+"');
+}
+function getExCommandAliases(command) {
+  const aliases = command.aliases;
+  if (aliases === undefined) {
+    return [];
+  }
+  return normalizeExCommandAliases(aliases);
+}
+function isExCommand(command) {
+  return command.name.trim().startsWith(":") || command.namespace === "excommands";
+}
+function parseCommandInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("Invalid keymap command: command cannot be empty");
+  }
+  const parts = trimmed.split(/\s+/);
+  const [name, ...args] = parts;
+  if (!name) {
+    throw new Error(`Invalid keymap command "${input}"`);
+  }
+  return {
+    input: trimmed,
+    name,
+    args
+  };
+}
+function validateCommandArgs(command, args) {
+  if (command.nargs === undefined) {
+    return true;
+  }
+  const nargs = normalizeExCommandNargs(command.nargs);
+  const count = args.length;
+  if (nargs === "0") {
+    return count === 0;
+  }
+  if (nargs === "1") {
+    return count === 1;
+  }
+  if (nargs === "?") {
+    return count <= 1;
+  }
+  if (nargs === "*") {
+    return true;
+  }
+  if (nargs === "+") {
+    return count >= 1;
+  }
+  return true;
+}
+function createExCommandRegistration(command, name) {
+  const run = command.run;
+  return {
+    ...command,
+    name,
+    namespace: "excommands",
+    run(ctx) {
+      const payload = getExCommandPayload(ctx.input, ctx.payload);
+      if (!validateCommandArgs(command, payload.args)) {
+        return { ok: false, reason: "invalid-args" };
+      }
+      return run({
+        ...ctx,
+        command: ctx.command,
+        payload
+      });
+    }
+  };
+}
+function registerExCommands(keymap) {
+  return keymap.acquireResource(EX_COMMANDS_RESOURCE, () => {
+    const offFields = keymap.registerCommandFields({
+      aliases(value) {
+        normalizeExCommandAliases(value);
+      },
+      nargs(value) {
+        normalizeExCommandNargs(value);
+      }
+    });
+    const offTransformer = keymap.appendCommandTransformer((command, ctx) => {
+      if (!isExCommand(command)) {
+        return;
+      }
+      ctx.skipOriginal();
+      if (command.nargs !== undefined) {
+        normalizeExCommandNargs(command.nargs);
+      }
+      const names = [command.name, ...getExCommandAliases(command)].map((name) => normalizeExCommandName(name));
+      for (const name of names) {
+        ctx.add(createExCommandRegistration(command, name));
+      }
+    });
+    const offResolver = keymap.appendCommandResolver((input, ctx) => {
+      if (!input.startsWith(":")) {
+        return;
+      }
+      const parsed = parseCommandInput(input);
+      const normalizedName = normalizeExCommandName(parsed.name);
+      const command = ctx.getCommand(normalizedName);
+      if (!command) {
+        return;
+      }
+      ctx.setInput(parsed.input);
+      ctx.setPayload({ raw: parsed.input, args: parsed.args, payload: ctx.payload });
+      return command;
+    });
+    return () => {
+      offResolver();
+      offTransformer();
+      offFields();
+    };
+  });
+}
+// src/addons/universal/leader.ts
+function registerLeader(keymap, options) {
+  return keymap.registerToken({
+    name: options.name ?? "leader",
+    key: options.trigger
+  });
+}
+// src/addons/universal/metadata.ts
+var METADATA_FIELDS_RESOURCE = Symbol("keymap:metadata-fields");
+function normalizeMetadataText(fieldName, value) {
+  if (typeof value !== "string") {
+    throw new Error(`Keymap metadata field "${fieldName}" must be a string`);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`Keymap metadata field "${fieldName}" cannot be empty`);
+  }
+  return trimmed;
+}
+function registerMetadataFields(keymap) {
+  return keymap.acquireResource(METADATA_FIELDS_RESOURCE, () => {
+    const offBindingFields = keymap.registerBindingFields({
+      desc(value, ctx) {
+        ctx.attr("desc", normalizeMetadataText("desc", value));
+      },
+      group(value, ctx) {
+        ctx.attr("group", normalizeMetadataText("group", value));
+      }
+    });
+    const offCommandFields = keymap.registerCommandFields({
+      desc(value, ctx) {
+        ctx.attr("desc", normalizeMetadataText("desc", value));
+      },
+      title(value, ctx) {
+        ctx.attr("title", normalizeMetadataText("title", value));
+      },
+      category(value, ctx) {
+        ctx.attr("category", normalizeMetadataText("category", value));
+      }
+    });
+    return () => {
+      offCommandFields();
+      offBindingFields();
+    };
+  });
+}
+// src/addons/universal/mod-bindings.ts
+var MOD_BINDINGS_RESOURCE = Symbol("keymap:mod-bindings");
+var MOD_MODIFIER_PATTERN = /(^|[+,\s])mod(?=\s*\+)/i;
+var MOD_MODIFIER_REPLACE_PATTERN = /(^|[+,\s])mod(?=\s*\+)/gi;
+function resolveModModifier(metadata) {
+  const primary = metadata.primaryModifier;
+  if ((primary === "ctrl" || primary === "super") && metadata.modifiers[primary] !== "unsupported") {
+    return primary;
+  }
+  if (metadata.modifiers.ctrl !== "unsupported") {
+    return "ctrl";
+  }
+  return "super";
+}
+function createDisplays(input) {
+  if (input.includes(",")) {
+    return [input];
+  }
+  const trimmed = input.trim();
+  return trimmed.includes(" ") ? trimmed.split(/\s+/) : [input];
+}
+function registerModBindings(keymap) {
+  return keymap.acquireResource(MOD_BINDINGS_RESOURCE, () => {
+    const expandModBinding = ({ input, displays }) => {
+      if (!MOD_MODIFIER_PATTERN.test(input)) {
+        return;
+      }
+      const modifier = resolveModModifier(keymap.getHostMetadata());
+      return [
+        {
+          key: input.replace(MOD_MODIFIER_REPLACE_PATTERN, (_match, prefix) => `${prefix}${modifier}`),
+          displays: displays ?? createDisplays(input)
+        }
+      ];
+    };
+    return keymap.appendBindingExpander(expandModBinding);
+  });
+}
+// src/addons/universal/neovim-disambiguation.ts
+function registerNeovimDisambiguation(keymap, options) {
+  const timeoutMs = options?.timeoutMs ?? 300;
+  return keymap.appendDisambiguationResolver((ctx) => {
+    return ctx.defer(async (deferred) => {
+      const elapsed = await deferred.sleep(timeoutMs);
+      if (!elapsed) {
+        return;
+      }
+      return deferred.runExact();
+    });
+  });
+}
+// src/addons/universal/timed-leader.ts
+function registerTimedLeader(keymap, options) {
+  const matchesTrigger = keymap.createKeyMatcher(options.trigger);
+  const timeoutMs = options.timeoutMs ?? 1500;
+  let armed = false;
+  let timeout;
+  const clearTimer = () => {
+    if (!timeout) {
+      return;
+    }
+    clearTimeout(timeout);
+    timeout = undefined;
+  };
+  const scheduleTimeout = () => {
+    clearTimer();
+    timeout = setTimeout(() => {
+      keymap.clearPendingSequence();
+    }, timeoutMs);
+  };
+  const syncArmedState = (sequence) => {
+    const nextArmed = matchesTrigger(sequence[0]);
+    if (nextArmed) {
+      scheduleTimeout();
+    } else {
+      clearTimer();
+    }
+    if (nextArmed === armed) {
+      return;
+    }
+    armed = nextArmed;
+    if (armed) {
+      options.onArm?.();
+      return;
+    }
+    options.onDisarm?.();
+  };
+  const offLeader = registerLeader(keymap, options);
+  const offPendingSequenceChange = keymap.on("pendingSequence", (sequence) => {
+    syncArmedState(sequence);
+  });
+  syncArmedState(keymap.getPendingSequence());
+  const dispose = () => {
+    clearTimer();
+    offPendingSequenceChange();
+    offLeader();
+    if (!armed) {
+      return;
+    }
+    armed = false;
+    options.onDisarm?.();
+  };
+  return dispose;
+}
+// src/addons/universal/unresolved-commands.ts
+import { stringifyKeySequence as stringifyKeySequence2, stringifyKeyStroke as stringifyKeyStroke2 } from "@opentui/keymap";
+var UNRESOLVED_COMMAND_WARNINGS_RESOURCE = Symbol("keymap:unresolved-command-warnings");
+function warnUnresolvedCommand(ctx, binding) {
+  if (typeof binding.command !== "string") {
+    return;
+  }
+  if (ctx.checkCommandResolution(binding.command) !== "unresolved") {
+    return;
+  }
+  const sequence = stringifyKeySequence2(binding.parsedBinding.sequence, { preferDisplay: true });
+  const sourceKey = typeof binding.parsedBinding.key === "string" ? binding.parsedBinding.key : stringifyKeyStroke2(binding.parsedBinding.key);
+  const warning = {
+    command: binding.command,
+    binding: binding.parsedBinding,
+    target: binding.sourceTarget
+  };
+  ctx.warnOnce(`unresolved:${binding.sourceLayerOrder}:${binding.bindingIndex}:${binding.command}:${sourceKey}`, "unresolved-command", warning, `[Keymap] Unresolved command "${binding.command}" for binding "${sequence}"`);
+}
+function registerUnresolvedCommandWarnings(keymap) {
+  return keymap.acquireResource(UNRESOLVED_COMMAND_WARNINGS_RESOURCE, () => {
+    return keymap.appendLayerAnalyzer((ctx) => {
+      for (const binding of ctx.bindings) {
+        warnUnresolvedCommand(ctx, binding);
+      }
+    });
+  });
+}
+export {
+  registerUnresolvedCommandWarnings,
+  registerTimedLeader,
+  registerNeovimDisambiguation,
+  registerModBindings,
+  registerMetadataFields,
+  registerLeader,
+  registerExCommands,
+  registerEscapeClearsPendingSequence,
+  registerEnabledFields,
+  registerEmacsBindings,
+  registerDefaultKeys,
+  registerDefaultEventMatchResolver,
+  registerDefaultBindingParser,
+  registerDeadBindingWarnings,
+  registerCommaBindings,
+  registerBindingOverrides,
+  registerBackspacePopsPendingSequence,
+  registerAliasesField,
+  defaultEventMatchResolver,
+  defaultBindingParser
+};
+
+//# debugId=BC9676433CEF75A964756E2164756E21
+//# sourceMappingURL=index.js.map